monkeybrain-runtime 1.0.0__py3-none-any.whl

src/cingulate/benchmark/validator.py

@@ -0,0 +1,102 @@
+"""Result Validator — validates benchmark results.
+
+Validates:
+- Input/Output correctness
+- State changes
+- Persistence changes
+- Response format
+- Performance thresholds
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ValidationResult:
+    """Result of a validation check."""
+    
+    check_name: str = ""
+    passed: bool = False
+    expected: Any = None
+    actual: Any = None
+    message: str = ""
+    severity: str = "error"  # error | warning | info
+
+
+class ResultValidator:
+    """Validates benchmark results.
+    
+    Responsibilities:
+    - Validate expected vs actual outputs
+    - Check performance thresholds
+    - Verify state consistency
+    """
+    
+    def __init__(self):
+        self._validations: list[ValidationResult] = []
+    
+    def validate_equal(self, name: str, expected: Any, actual: Any) -> ValidationResult:
+        """Validate equality."""
+        result = ValidationResult(
+            check_name=name,
+            expected=expected,
+            actual=actual,
+            passed=expected == actual,
+            message=f"Expected {expected}, got {actual}" if expected != actual else "OK",
+        )
+        self._validations.append(result)
+        return result
+    
+    def validate_contains(self, name: str, haystack: Any, needle: Any) -> ValidationResult:
+        """Validate containment."""
+        result = ValidationResult(
+            check_name=name,
+            expected=needle,
+            actual=haystack,
+            passed=needle in haystack if haystack else False,
+            message=f"Expected {needle} in {haystack}" if needle not in (haystack or []) else "OK",
+        )
+        self._validations.append(result)
+        return result
+    
+    def validate_latency(self, name: str, latency_ms: float, max_ms: float) -> ValidationResult:
+        """Validate latency threshold."""
+        result = ValidationResult(
+            check_name=name,
+            expected=f"< {max_ms}ms",
+            actual=f"{latency_ms:.2f}ms",
+            passed=latency_ms <= max_ms,
+            message=f"Latency {latency_ms:.2f}ms exceeds {max_ms}ms" if latency_ms > max_ms else "OK",
+            severity="warning",
+        )
+        self._validations.append(result)
+        return result
+    
+    def validate_success_rate(self, name: str, passed: int, total: int, min_rate: float = 0.9) -> ValidationResult:
+        """Validate success rate."""
+        rate = passed / total if total else 0
+        result = ValidationResult(
+            check_name=name,
+            expected=f">= {min_rate*100}%",
+            actual=f"{rate*100:.1f}%",
+            passed=rate >= min_rate,
+            message=f"Success rate {rate*100:.1f}% below {min_rate*100}%" if rate < min_rate else "OK",
+        )
+        self._validations.append(result)
+        return result
+    
+    def get_results(self) -> list[ValidationResult]:
+        return list(self._validations)
+    
+    def summary(self) -> dict:
+        total = len(self._validations)
+        passed = sum(1 for v in self._validations if v.passed)
+        return {
+            "total": total,
+            "passed": passed,
+            "failed": total - passed,
+            "pass_rate": round(passed / total, 3) if total else 0,
+        }

src/cingulate/governance/__init__.py

@@ -0,0 +1,21 @@
+"""Governance — constitutional authority of AgentOS.
+
+Every subsystem is governed.
+No subsystem is exempt.
+"""
+
+from src.cingulate.governance.governance import Governance
+from src.cingulate.governance.policy_registry import PolicyRegistry, Policy, PolicyCategory
+from src.cingulate.governance.architecture_validator import ArchitectureValidator, Violation
+from src.cingulate.governance.compliance import ComplianceEngine, ComplianceCheck
+
+__all__ = [
+    "Governance",
+    "PolicyRegistry",
+    "Policy",
+    "PolicyCategory",
+    "ArchitectureValidator",
+    "Violation",
+    "ComplianceEngine",
+    "ComplianceCheck",
+]

src/cingulate/governance/architecture_validator.py

@@ -0,0 +1,194 @@
+"""Architecture Validator — validates architectural compliance.
+
+Continuously validates:
+- SOLID
+- DRY
+- Layer isolation
+- Circular dependencies
+- Ownership boundaries
+- Single responsibility
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass
+class Violation:
+    """An architectural violation."""
+    
+    violation_id: str = field(default_factory=lambda: f"viol-{uuid4().hex[:8]}")
+    rule: str = ""
+    severity: str = "medium"  # critical | high | medium | low
+    file_path: str = ""
+    line: int = 0
+    description: str = ""
+    recommendation: str = ""
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+
+@dataclass
+class ComplianceReport:
+    """Architecture compliance report."""
+    
+    report_id: str = field(default_factory=lambda: f"report-{uuid4().hex[:8]}")
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    total_files: int = 0
+    total_violations: int = 0
+    violations_by_severity: dict[str, int] = field(default_factory=dict)
+    violations: list[Violation] = field(default_factory=list)
+    score: float = 100.0
+
+
+class ArchitectureValidator:
+    """Validates architectural compliance.
+    
+    Continuously validates:
+    - SOLID
+    - DRY
+    - Layer isolation
+    - Circular dependencies
+    """
+    
+    def __init__(self, root_dir: str = "services/agentos"):
+        self._root_dir = root_dir
+        self._violations: list[Violation] = []
+    
+    def validate_all(self) -> ComplianceReport:
+        """Run all architecture validations."""
+        report = ComplianceReport()
+        
+        self._check_large_files(report)
+        self._check_duplicate_classes(report)
+        self._check_circular_dependencies(report)
+        self._check_hardcoded_policies(report)
+        
+        report.violations = self._violations
+        report.total_violations = len(self._violations)
+        report.violations_by_severity = {}
+        for v in self._violations:
+            report.violations_by_severity[v.severity] = report.violations_by_severity.get(v.severity, 0) + 1
+        
+        # Calculate score
+        critical = report.violations_by_severity.get("critical", 0)
+        high = report.violations_by_severity.get("high", 0)
+        medium = report.violations_by_severity.get("medium", 0)
+        low = report.violations_by_severity.get("low", 0)
+        report.score = max(0, 100 - (critical * 10) - (high * 5) - (medium * 2) - (low * 0.5))
+        
+        return report
+    
+    def _check_large_files(self, report: ComplianceReport) -> None:
+        """Check for files exceeding line limits."""
+        for root, dirs, files in os.walk(self._root_dir):
+            for f in files:
+                if f.endswith('.py'):
+                    path = os.path.join(root, f)
+                    report.total_files += 1
+                    with open(path) as fh:
+                        lines = len(fh.readlines())
+                    if lines > 1000:
+                        self._violations.append(Violation(
+                            rule="single_responsibility",
+                            severity="high",
+                            file_path=path,
+                            description=f"File has {lines} lines (exceeds 1000)",
+                            recommendation="Decompose into smaller modules",
+                        ))
+                    elif lines > 500:
+                        self._violations.append(Violation(
+                            rule="single_responsibility",
+                            severity="medium",
+                            file_path=path,
+                            description=f"File has {lines} lines (exceeds 500)",
+                            recommendation="Consider decomposition",
+                        ))
+    
+    def _check_duplicate_classes(self, report: ComplianceReport) -> None:
+        """Check for duplicate class definitions."""
+        class_defs: dict[str, list[str]] = {}
+        for root, dirs, files in os.walk(self._root_dir):
+            for f in files:
+                if f.endswith('.py'):
+                    path = os.path.join(root, f)
+                    with open(path) as fh:
+                        content = fh.read()
+                    matches = re.findall(r'class (\w+)', content)
+                    for m in matches:
+                        if m not in class_defs:
+                            class_defs[m] = []
+                        class_defs[m].append(path)
+        
+        for cls, paths in class_defs.items():
+            if len(paths) > 1 and cls not in ('Exception', 'Error', 'Enum'):
+                self._violations.append(Violation(
+                    rule="dry",
+                    severity="medium",
+                    file_path=paths[0],
+                    description=f"Class '{cls}' defined in {len(paths)} files",
+                    recommendation="Consolidate into single definition",
+                ))
+    
+    def _check_circular_dependencies(self, report: ComplianceReport) -> None:
+        """Check for circular dependencies."""
+        deps: dict[str, set[str]] = {}
+        for root, dirs, files in os.walk(self._root_dir):
+            for f in files:
+                if f.endswith('.py'):
+                    path = os.path.join(root, f)
+                    module = path.replace('/', '.').replace('.py', '')
+                    deps[module] = set()
+                    with open(path) as fh:
+                        for line in fh:
+                            m = re.match(r'from (services\.agentos\.\S+) import', line)
+                            if m:
+                                deps[module].add(m.group(1))
+        
+        for mod, imports in deps.items():
+            for imp in imports:
+                if imp in deps and mod in deps[imp]:
+                    self._violations.append(Violation(
+                        rule="no_circular_dependencies",
+                        severity="critical",
+                        file_path=mod.replace('.', '/') + '.py',
+                        description=f"Circular dependency: {mod} <-> {imp}",
+                        recommendation="Break circular dependency",
+                    ))
+    
+    def _check_hardcoded_policies(self, report: ComplianceReport) -> None:
+        """Check for hardcoded policy values."""
+        patterns = [
+            (r'confidence\s*[><=]\s*\d+\.\d+', "Hardcoded confidence threshold"),
+            (r'exploration_rate\s*=\s*\d+\.\d+', "Hardcoded exploration rate"),
+            (r'learning_rate\s*=\s*\d+\.\d+', "Hardcoded learning rate"),
+            (r'max_size\s*=\s*\d+', "Hardcoded max size"),
+        ]
+        
+        for root, dirs, files in os.walk(self._root_dir):
+            for f in files:
+                if f.endswith('.py'):
+                    path = os.path.join(root, f)
+                    with open(path) as fh:
+                        content = fh.read()
+                    for pattern, desc in patterns:
+                        matches = re.findall(pattern, content)
+                        if matches:
+                            self._violations.append(Violation(
+                                rule="configurable_policies",
+                                severity="low",
+                                file_path=path,
+                                description=f"{desc}: {matches[0][:40]}",
+                                recommendation="Make configurable",
+                            ))
+    
+    def summary(self) -> dict:
+        return {
+            "violations": len(self._violations),
+            "by_severity": {},
+        }

src/cingulate/governance/compliance.py

@@ -0,0 +1,104 @@
+"""Compliance Engine — validates compliance with policies and constitutions.
+
+Validates:
+- Constitutional compliance
+- Policy compliance
+- Security compliance
+- Data compliance
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass
+class ComplianceCheck:
+    """A single compliance check result."""
+    
+    check_id: str = field(default_factory=lambda: f"check-{uuid4().hex[:8]}")
+    policy_id: str = ""
+    subsystem: str = ""
+    rule: str = ""
+    passed: bool = False
+    message: str = ""
+    severity: str = "medium"
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+
+@dataclass
+class ComplianceReport:
+    """Compliance report for a subsystem."""
+    
+    report_id: str = field(default_factory=lambda: f"comp-{uuid4().hex[:8]}")
+    subsystem: str = ""
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    checks: list[ComplianceCheck] = field(default_factory=list)
+    total_checks: int = 0
+    passed_checks: int = 0
+    failed_checks: int = 0
+    compliance_score: float = 0.0
+
+
+class ComplianceEngine:
+    """Validates compliance with policies and constitutions.
+    
+    Responsibilities:
+    - Validate constitutional compliance
+    - Validate policy compliance
+    - Generate compliance reports
+    """
+    
+    def __init__(self):
+        self._checks: list[ComplianceCheck] = []
+        self._reports: list[ComplianceReport] = []
+    
+    def check(self, subsystem: str, rule: str, passed: bool, message: str = "", severity: str = "medium") -> ComplianceCheck:
+        """Run a compliance check."""
+        check = ComplianceCheck(
+            subsystem=subsystem,
+            rule=rule,
+            passed=passed,
+            message=message,
+            severity=severity,
+        )
+        self._checks.append(check)
+        return check
+    
+    def validate_subsystem(self, subsystem: str, rules: list[dict[str, Any]]) -> ComplianceReport:
+        """Validate a subsystem against a set of rules."""
+        report = ComplianceReport(subsystem=subsystem)
+        
+        for rule in rules:
+            check = self.check(
+                subsystem=subsystem,
+                rule=rule.get("name", ""),
+                passed=rule.get("passed", False),
+                message=rule.get("message", ""),
+                severity=rule.get("severity", "medium"),
+            )
+            report.checks.append(check)
+        
+        report.total_checks = len(report.checks)
+        report.passed_checks = sum(1 for c in report.checks if c.passed)
+        report.failed_checks = report.total_checks - report.passed_checks
+        report.compliance_score = report.passed_checks / report.total_checks if report.total_checks else 0.0
+        
+        self._reports.append(report)
+        return report
+    
+    def get_reports(self, subsystem: str | None = None) -> list[ComplianceReport]:
+        if subsystem:
+            return [r for r in self._reports if r.subsystem == subsystem]
+        return list(self._reports)
+    
+    def summary(self) -> dict:
+        return {
+            "total_checks": len(self._checks),
+            "passed": sum(1 for c in self._checks if c.passed),
+            "failed": sum(1 for c in self._checks if not c.passed),
+            "reports": len(self._reports),
+        }

src/cingulate/governance/governance.py

@@ -0,0 +1,77 @@
+"""Governance Engine — constitutional authority of AgentOS.
+
+Every subsystem is governed.
+No subsystem is exempt.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from src.cingulate.governance.policy_registry import PolicyRegistry, Policy, PolicyCategory
+from src.cingulate.governance.architecture_validator import ArchitectureValidator, ComplianceReport as ArchReport
+from src.cingulate.governance.compliance import ComplianceEngine, ComplianceReport
+
+
+class Governance:
+    """Constitutional authority of AgentOS.
+    
+    Responsibilities:
+    - Policy management
+    - Architecture validation
+    - Compliance checking
+    - Audit trail
+    """
+    
+    def __init__(self):
+        self.policies = PolicyRegistry()
+        self.architecture = ArchitectureValidator()
+        self.compliance = ComplianceEngine()
+        self._lemon = None
+    
+    def set_lemon(self, lemon) -> None:
+        self._lemon = lemon
+    
+    # --- Policy Management ---
+    
+    def register_policy(self, policy: Policy) -> str:
+        """Register a governance policy."""
+        policy_id = self.policies.register(policy)
+        if self._lemon:
+            self._lemon.counter("governance.policies_registered")
+        return policy_id
+    
+    def get_policy(self, policy_id: str) -> Policy | None:
+        return self.policies.get(policy_id)
+    
+    def get_policies_by_category(self, category: PolicyCategory) -> list[Policy]:
+        return self.policies.get_by_category(category)
+    
+    # --- Architecture Validation ---
+    
+    def validate_architecture(self) -> ArchReport:
+        """Run architecture compliance audit."""
+        report = self.architecture.validate_all()
+        if self._lemon:
+            self._lemon.counter("governance.architecture_audits")
+            self._lemon.gauge("governance.violations", report.total_violations)
+        return report
+    
+    # --- Compliance ---
+    
+    def check_compliance(self, subsystem: str, rule: str, passed: bool, message: str = "") -> Any:
+        """Run a compliance check."""
+        return self.compliance.check(subsystem, rule, passed, message)
+    
+    def validate_subsystem(self, subsystem: str, rules: list[dict[str, Any]]) -> ComplianceReport:
+        """Validate a subsystem against rules."""
+        return self.compliance.validate_subsystem(subsystem, rules)
+    
+    # --- Summary ---
+    
+    def summary(self) -> dict:
+        return {
+            "policies": self.policies.summary(),
+            "architecture": self.architecture.summary(),
+            "compliance": self.compliance.summary(),
+        }

src/cingulate/governance/policy_registry.py

@@ -0,0 +1,91 @@
+"""Policy Registry — centralized policy definitions.
+
+All policies are versioned and auditable.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any
+from uuid import uuid4
+
+
+class PolicyCategory(str, Enum):
+    SECURITY = "security"
+    RUNTIME = "runtime"
+    SCHEDULING = "scheduling"
+    LIFECYCLE = "lifecycle"
+    MEMORY = "memory"
+    CAPABILITY = "capability"
+    LEARNING = "learning"
+    COST = "cost"
+    DATA = "data"
+    COMPLIANCE = "compliance"
+
+
+@dataclass
+class Policy:
+    """A governance policy."""
+    
+    policy_id: str = field(default_factory=lambda: f"policy-{uuid4().hex[:8]}")
+    name: str = ""
+    category: PolicyCategory = PolicyCategory.RUNTIME
+    version: str = "1.0.0"
+    description: str = ""
+    rules: list[dict[str, Any]] = field(default_factory=list)
+    enabled: bool = True
+    metadata: dict[str, Any] = field(default_factory=dict)
+    created_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    updated_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+
+class PolicyRegistry:
+    """Centralized policy definitions.
+    
+    All policies are versioned and auditable.
+    """
+    
+    def __init__(self):
+        self._policies: dict[str, Policy] = {}
+    
+    def register(self, policy: Policy) -> str:
+        """Register a policy."""
+        self._policies[policy.policy_id] = policy
+        return policy.policy_id
+    
+    def get(self, policy_id: str) -> Policy | None:
+        return self._policies.get(policy_id)
+    
+    def get_by_category(self, category: PolicyCategory) -> list[Policy]:
+        return [p for p in self._policies.values() if p.category == category]
+    
+    def get_all(self) -> list[Policy]:
+        return list(self._policies.values())
+    
+    def update(self, policy_id: str, **kwargs: Any) -> bool:
+        if policy_id in self._policies:
+            policy = self._policies[policy_id]
+            for key, value in kwargs.items():
+                if hasattr(policy, key):
+                    setattr(policy, key, value)
+            policy.updated_at = datetime.now(timezone.utc).isoformat()
+            return True
+        return False
+    
+    def remove(self, policy_id: str) -> bool:
+        if policy_id in self._policies:
+            del self._policies[policy_id]
+            return True
+        return False
+    
+    def summary(self) -> dict:
+        categories = {}
+        for p in self._policies.values():
+            cat = p.category.value
+            categories[cat] = categories.get(cat, 0) + 1
+        return {
+            "total": len(self._policies),
+            "by_category": categories,
+        }

src/cortex/__init__.py

@@ -0,0 +1,33 @@
+"""MonkeyBrain World Model (Xavier).
+
+The simulator injects Kernel and Runtime.
+The simulator never duplicates either.
+Simulation executes identical pipelines to production.
+
+Responsibilities:
+- Digital Twins: virtual replicas of real-world entities
+- Prediction: forecast pipeline outcomes
+- Replay: replay historical executions
+- Counterfactual: execute alternative scenarios
+- World State: maintain current, expected, and counterfactual states
+"""
+
+from src.cortex.digital_twin import DigitalTwin, TwinState
+from src.cortex.prediction import PredictionEngine, Prediction
+from src.cortex.replay import ReplayEngine, Recording, Comparison
+from src.cortex.counterfactual import CounterfactualEngine, Scenario
+from src.cortex.world_state import WorldState, WorldSnapshot
+
+__all__ = [
+    "DigitalTwin",
+    "TwinState",
+    "PredictionEngine",
+    "Prediction",
+    "ReplayEngine",
+    "Recording",
+    "Comparison",
+    "CounterfactualEngine",
+    "Scenario",
+    "WorldState",
+    "WorldSnapshot",
+]

src/cortex/cost.py

@@ -0,0 +1,71 @@
+"""Cost Engine — estimates execution cost.
+
+Cost includes:
+- CPU
+- Memory
+- Storage
+- Network
+- Database
+- Token Usage
+- LLM Cost
+- External API Cost
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class CostEstimate:
+    """Estimated cost of an execution."""
+    
+    total_cost: float = 0.0
+    components: dict[str, float] = field(default_factory=dict)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class CostEngine:
+    """Estimates execution cost.
+    
+    Optimization considers both correctness and cost.
+    """
+    
+    def __init__(self):
+        self._cost_rates: dict[str, float] = {
+            "cpu_per_ms": 0.0001,
+            "memory_per_mb": 0.001,
+            "storage_per_mb": 0.0005,
+            "network_per_kb": 0.0001,
+            "database_per_query": 0.001,
+            "token_per_1k": 0.002,
+            "llm_per_call": 0.01,
+            "api_per_call": 0.005,
+        }
+    
+    def estimate(
+        self,
+        latency_ms: float = 0.0,
+        memory_mb: float = 0.0,
+        database_queries: int = 0,
+        tokens: int = 0,
+        llm_calls: int = 0,
+        api_calls: int = 0,
+    ) -> CostEstimate:
+        """Estimate execution cost."""
+        components = {}
+        
+        components["cpu"] = latency_ms * self._cost_rates["cpu_per_ms"]
+        components["memory"] = memory_mb * self._cost_rates["memory_per_mb"]
+        components["database"] = database_queries * self._cost_rates["database_per_query"]
+        components["tokens"] = (tokens / 1000) * self._cost_rates["token_per_1k"]
+        components["llm"] = llm_calls * self._cost_rates["llm_per_call"]
+        components["api"] = api_calls * self._cost_rates["api_per_call"]
+        
+        total = sum(components.values())
+        
+        return CostEstimate(
+            total_cost=total,
+            components=components,
+        )