novyx 0.1.0__tar.gz

novyx-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: novyx
+Version: 0.1.0
+Summary: Unified Novyx SDK (Core + RAM + Sentinel)
+Requires-Python: >=3.9
+Requires-Dist: requests
+Requires-Dist: pydantic
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

novyx-0.1.0/README.md

@@ -0,0 +1,44 @@
+# Novyx SDK
+
+Unified SDK for Novyx Core + RAM + Sentinel.
+
+## Install (local)
+
+```bash
+pip install -e ./sdk
+```
+
+## Quick Start
+
+```python
+from novyx import Novyx
+
+nx = Novyx(
+    api_key="nram_...",
+    api_url="https://novyx-ram-api.fly.dev",
+    sentinel_url="https://novyx-sentinel.fly.dev",
+    strict=False,
+)
+
+result = nx.remember("User prefers dark mode", tags=["ui", "preference"])
+memories = nx.recall("UI preferences", limit=5)
+nx.act("send_email", {"to": "user@example.com"})
+nx.rollback("2025-01-30T14:00:00Z")
+```
+
+## Four Verbs
+
+- `remember(content, tags=[])` → store memory with cryptographic hash
+- `recall(query, limit=5)` → semantic search (uses `q` param)
+- `act(action_name, params)` → Sentinel policy check before action
+- `rollback(target)` → Magic Rollback™ (timestamp or artifact id)
+
+## Enterprise Telemetry
+
+Set `NOVYX_TIER=enterprise` to enable audit pulse logging to the Core audit trail.
+
+## Test Drive
+
+```bash
+python sdk/test_drive.py
+```

novyx-0.1.0/novyx/__init__.py

@@ -0,0 +1,9 @@
+from .client import Novyx
+from .exceptions import NovyxAuthError, NovyxSecurityError, NovyxStorageError
+
+__all__ = [
+    "Novyx",
+    "NovyxAuthError",
+    "NovyxSecurityError",
+    "NovyxStorageError",
+]

novyx-0.1.0/novyx/auth.py

@@ -0,0 +1,20 @@
+from extensions.novyx_ram.sdk import NovyxRAMClient, AuthenticationError, NovyxRAMError
+
+from .exceptions import NovyxAuthError, NovyxStorageError
+
+
+def validate_api_key(api_key: str, api_url: str) -> None:
+    """
+    Validate RAM API key by calling an authenticated endpoint.
+
+    Raises:
+        NovyxAuthError: If the API key is invalid.
+        NovyxStorageError: If the API is unreachable.
+    """
+    try:
+        client = NovyxRAMClient(api_key=api_key, base_url=api_url)
+        _ = client.stats()
+    except AuthenticationError as exc:
+        raise NovyxAuthError("Invalid Novyx API key.") from exc
+    except NovyxRAMError as exc:
+        raise NovyxStorageError(str(exc)) from exc

novyx-0.1.0/novyx/client.py

@@ -0,0 +1,261 @@
+import hashlib
+import json
+import os
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from extensions.novyx_ram.sdk import (
+    NovyxRAMClient,
+    NovyxRAMError,
+    AuthenticationError,
+)
+from sentinel.circuit_breaker import PolicyEvaluator, EvaluationMode
+from sentinel.trace_models import SentinelTraceStep, StepType, PolicyStatus
+from sentinel.rollback_analyzer import RollbackAnalyzer
+from sentinel.surgical_rollback import SurgicalRollback
+from security.forensic_rollback import ForensicRollback
+
+from .auth import validate_api_key
+from .exceptions import NovyxAuthError, NovyxSecurityError, NovyxStorageError
+from .telemetry import TelemetryLogger
+
+
+class Novyx:
+    """
+    Unified SDK interface for Novyx Core + RAM + Sentinel.
+
+    Four verbs:
+    - remember
+    - recall
+    - act
+    - rollback
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        api_url: str = "https://novyx-ram-api.fly.dev",
+        sentinel_url: str = "https://novyx-sentinel.fly.dev",
+        session_id: Optional[str] = None,
+        strict: bool = False,
+    ):
+        self.api_key = api_key
+        self.api_url = api_url.rstrip("/")
+        self.sentinel_url = sentinel_url.rstrip("/")
+        self.session_id = session_id or f"session_{uuid.uuid4()}"
+        self.strict = strict
+
+        validate_api_key(api_key=self.api_key, api_url=self.api_url)
+
+        try:
+            self.ram = NovyxRAMClient(api_key=self.api_key, base_url=self.api_url)
+        except AuthenticationError as exc:
+            raise NovyxAuthError("Invalid Novyx API key.") from exc
+        except NovyxRAMError as exc:
+            raise NovyxStorageError(str(exc)) from exc
+
+        self.telemetry = TelemetryLogger(session_id=self.session_id)
+        self.policy_evaluator = PolicyEvaluator(mode=EvaluationMode.ENFORCEMENT)
+
+        self._memory_count = 0
+        self._action_count = 0
+
+    def _now_iso(self) -> str:
+        return datetime.now(timezone.utc).isoformat()
+
+    def _hash_content(self, content: str, tags: List[str]) -> str:
+        payload = {
+            "content": content,
+            "tags": tags,
+            "session_id": self.session_id,
+        }
+        digest = hashlib.sha256(
+            json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
+        ).hexdigest()
+        return f"urn:sha256:{digest}"
+
+    def _forge_debt_warning(self) -> None:
+        if not self.strict:
+            return
+
+        if self._action_count == 0:
+            ratio = f"{self._memory_count}:0"
+        else:
+            ratio = f"{self._memory_count}:{self._action_count}"
+
+        print(
+            "Warning: "
+            f"{self._memory_count} memories stored, "
+            f"{self._action_count} actions taken. "
+            f"Consumption debt ratio: {ratio}"
+        )
+
+    def remember(self, content: str, tags: Optional[List[str]] = None) -> Dict[str, Any]:
+        tags = tags or []
+        content_hash = self._hash_content(content, tags)
+
+        try:
+            result = self.ram.store(
+                observation=content,
+                tags=tags,
+                context=f"content_hash={content_hash}",
+                agent_id=self.session_id,
+            )
+        except NovyxRAMError as exc:
+            raise NovyxStorageError(str(exc)) from exc
+
+        self._memory_count += 1
+        self.telemetry.log_pulse(
+            "remember",
+            {
+                "session_id": self.session_id,
+                "memory_id": result.uuid,
+                "hash": content_hash,
+                "tags": tags,
+            },
+        )
+        self._forge_debt_warning()
+
+        return {
+            "id": result.uuid,
+            "hash": content_hash,
+            "stored_at": self._now_iso(),
+        }
+
+    def recall(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        try:
+            search_result = self.ram.search(query=query, limit=limit)
+        except NovyxRAMError as exc:
+            raise NovyxStorageError(str(exc)) from exc
+
+        retrieved_at = self._now_iso()
+        cleaned = []
+        for mem in search_result.memories:
+            cleaned.append(
+                {
+                    "uuid": mem.uuid,
+                    "observation": mem.observation,
+                    "context": mem.context,
+                    "tags": mem.tags,
+                    "agent_id": mem.agent_id,
+                    "created_at": mem.created_at,
+                    "score": mem.score,
+                    "query": query,
+                    "retrieved_at": retrieved_at,
+                    "session_id": self.session_id,
+                }
+            )
+
+        self.telemetry.log_pulse(
+            "recall",
+            {
+                "session_id": self.session_id,
+                "query": query,
+                "limit": limit,
+                "results": len(cleaned),
+            },
+        )
+        return cleaned
+
+    def act(self, action_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        self._check_sentinel()
+        content = json.dumps({"action": action_name, "params": params}, sort_keys=True)
+        integrity_hash = hashlib.sha256(content.encode("utf-8")).hexdigest()
+        chain_hash = hashlib.sha256(
+            (integrity_hash + ("0" * 64)).encode("utf-8")
+        ).hexdigest()
+
+        step = SentinelTraceStep(
+            trace_id=f"urn:uuid:{self.session_id}",
+            step_index=self._action_count,
+            step_type=StepType.ACTION,
+            content=content,
+            policy_status=PolicyStatus.SKIPPED,
+            integrity_hash=integrity_hash,
+            integrity_chain_hash=chain_hash,
+        )
+
+        evaluation = self.policy_evaluator.evaluate_step(step)
+        if evaluation.policy_status == PolicyStatus.FAILED:
+            violation = evaluation.violations[0]
+            raise NovyxSecurityError(
+                f"{violation.policy_name}: {violation.reason}"
+            )
+
+        self._action_count += 1
+        self.telemetry.log_pulse(
+            "act",
+            {
+                "session_id": self.session_id,
+                "action": action_name,
+                "params": params,
+                "policy_status": evaluation.policy_status.value,
+                "risk_score": evaluation.risk_score,
+            },
+        )
+
+        return {
+            "action": action_name,
+            "status": "approved",
+            "policy_status": evaluation.policy_status.value,
+            "risk_score": evaluation.risk_score,
+        }
+
+    def _check_sentinel(self) -> None:
+        try:
+            resp = requests.get(f"{self.sentinel_url}/health", timeout=5)
+        except requests.RequestException as exc:
+            raise NovyxSecurityError("Sentinel is unreachable.") from exc
+
+        if resp.status_code != 200:
+            raise NovyxSecurityError(
+                f"Sentinel integrity check failed (status {resp.status_code})."
+            )
+
+    def rollback(self, target: str) -> Dict[str, Any]:
+        memory_dir = os.getenv("NOVYX_MEMORY_DIR", "memory")
+        analyzer = RollbackAnalyzer(memory_dir=memory_dir)
+        rollback_engine = ForensicRollback(memory_dir=memory_dir)
+        surgical = SurgicalRollback(memory_dir=memory_dir, rollback=rollback_engine)
+
+        suggestion = None
+        if "T" in target and "Z" in target:
+            impact = analyzer.calculate_impact(target)
+            result = rollback_engine.execute_rollback(target)
+            suggestion = impact.get("suggestion") or "Rollback executed"
+            rolled_back = result.get("artifacts_restored", [])
+            preserved = result.get("artifacts_quarantined", [])
+        else:
+            # Treat as artifact_id; rollback to latest green point with dependencies
+            points = rollback_engine.list_rollback_points()
+            if not points:
+                raise NovyxStorageError("No rollback points available.")
+            latest = points[-1]
+            impact = analyzer.calculate_impact(latest.timestamp)
+            suggestion = impact.get("suggestion") or "Surgical rollback executed"
+            result = surgical.rollback_artifacts(
+                [target],
+                latest.timestamp,
+                include_dependencies=True,
+                dry_run=False,
+            ).to_dict()
+            rolled_back = result.get("artifacts_rolled_back", [])
+            preserved = result.get("artifacts_failed", [])
+
+        self.telemetry.log_pulse(
+            "rollback",
+            {
+                "session_id": self.session_id,
+                "target": target,
+                "suggestion": suggestion,
+            },
+        )
+
+        return {
+            "rolled_back": rolled_back,
+            "preserved": preserved,
+            "suggestion": suggestion,
+        }

novyx-0.1.0/novyx/exceptions.py

@@ -0,0 +1,10 @@
+class NovyxAuthError(Exception):
+    """Raised when API key authentication fails."""
+
+
+class NovyxSecurityError(Exception):
+    """Raised when Sentinel blocks an action or integrity check fails."""
+
+
+class NovyxStorageError(Exception):
+    """Raised when RAM or Core storage operations fail."""

novyx-0.1.0/novyx/telemetry.py

@@ -0,0 +1,56 @@
+import hashlib
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, Any, Union, Optional
+
+from security.audit_trail import AuditTrail, OperationType
+
+from .exceptions import NovyxStorageError
+
+
+class TelemetryLogger:
+    """
+    Enterprise-only audit logging for SDK usage.
+
+    Logs a Pulse event for each SDK call when NOVYX_TIER=enterprise.
+    """
+
+    def __init__(self, session_id: str, memory_dir: Optional[Union[str, Path]] = None):
+        self.session_id = session_id
+        self.tier = os.getenv("NOVYX_TIER", "").lower()
+        self.memory_dir = Path(memory_dir or os.getenv("NOVYX_MEMORY_DIR", "memory"))
+        self.audit_dir = self.memory_dir / ".audit"
+        self._audit = None
+
+        if self.tier == "enterprise":
+            try:
+                self._audit = AuditTrail(self.audit_dir, verify_on_load=False)
+            except Exception as exc:
+                raise NovyxStorageError(f"Failed to initialize audit trail: {exc}") from exc
+
+    def _hash_payload(self, payload: Dict[str, Any]) -> str:
+        content = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+        return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+    def log_pulse(self, verb: str, payload: Dict[str, Any]) -> None:
+        if self.tier != "enterprise":
+            return
+
+        if not self._audit:
+            raise NovyxStorageError("Audit trail not initialized.")
+
+        content_hash = self._hash_payload(payload)
+        timestamp = datetime.now(timezone.utc).isoformat()
+        self._audit.log(
+            operation=OperationType.ACCESS.value,
+            agent_id=self.session_id,
+            artifact_id=f"pulse:{verb}",
+            content_hash=content_hash,
+            metadata={
+                "verb": verb,
+                "timestamp": timestamp,
+                "payload": payload,
+            },
+        )

novyx-0.1.0/novyx.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: novyx
+Version: 0.1.0
+Summary: Unified Novyx SDK (Core + RAM + Sentinel)
+Requires-Python: >=3.9
+Requires-Dist: requests
+Requires-Dist: pydantic
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

novyx-0.1.0/novyx.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+setup.py
+./novyx/__init__.py
+./novyx/auth.py
+./novyx/client.py
+./novyx/exceptions.py
+./novyx/telemetry.py
+novyx/__init__.py
+novyx/auth.py
+novyx/client.py
+novyx/exceptions.py
+novyx/telemetry.py
+novyx.egg-info/PKG-INFO
+novyx.egg-info/SOURCES.txt
+novyx.egg-info/dependency_links.txt
+novyx.egg-info/requires.txt
+novyx.egg-info/top_level.txt

novyx-0.1.0/novyx.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

novyx-0.1.0/novyx.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests
+pydantic

novyx-0.1.0/novyx.egg-info/top_level.txt

@@ -0,0 +1 @@
+novyx

novyx-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

novyx-0.1.0/setup.py

@@ -0,0 +1,15 @@
+from setuptools import setup, find_packages
+
+
+setup(
+    name="novyx",
+    version="0.1.0",
+    description="Unified Novyx SDK (Core + RAM + Sentinel)",
+    package_dir={"": "."},
+    packages=find_packages("."),
+    install_requires=[
+        "requests",
+        "pydantic",
+    ],
+    python_requires=">=3.9",
+)