empathy-framework 5.2.1__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/memory/types.py

@@ -1,441 +0,0 @@
-"""Memory types and data classes for Empathy Framework.
-
-This module contains shared data structures used by the memory subsystem:
-- Access control (AccessTier, AgentCredentials)
-- TTL strategies (TTLStrategy)
-- Configuration (RedisConfig)
-- Metrics (RedisMetrics)
-- Query types (PaginatedResult, TimeWindowQuery)
-- Domain objects (StagedPattern, ConflictContext)
-- Exceptions (SecurityError)
-
-These types are independent of Redis and can be imported without the redis package.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from dataclasses import dataclass, field
-from datetime import datetime
-from enum import Enum
-from typing import Any
-
-
-class AccessTier(Enum):
-    """Role-based access tiers per EMPATHY_PHILOSOPHY.md
-
-    Tier 1 - Observer: Read-only access to validated patterns
-    Tier 2 - Contributor: Can stage patterns for validation
-    Tier 3 - Validator: Can promote staged patterns to active
-    Tier 4 - Steward: Full access including deprecation and audit
-    """
-
-    OBSERVER = 1
-    CONTRIBUTOR = 2
-    VALIDATOR = 3
-    STEWARD = 4
-
-
-class TTLStrategy(Enum):
-    """TTL strategies for different memory types
-
-    Per EMPATHY_PHILOSOPHY.md Section 9.3:
-    - Working results: 1 hour
-    - Staged patterns: 24 hours
-    - Coordination signals: 5 minutes (REMOVED in v5.0 - see CoordinationSignals)
-    - Conflict context: Until resolution
-    """
-
-    WORKING_RESULTS = 3600  # 1 hour
-    STAGED_PATTERNS = 86400  # 24 hours
-    # COORDINATION removed in v5.0 - use CoordinationSignals with custom TTLs
-    CONFLICT_CONTEXT = 604800  # 7 days (fallback for unresolved)
-    SESSION = 1800  # 30 minutes
-    STREAM_ENTRY = 86400 * 7  # 7 days for audit stream entries
-    TASK_QUEUE = 3600 * 4  # 4 hours for task queue items
-
-
-@dataclass
-class RedisConfig:
-    """Enhanced Redis configuration with SSL and retry support.
-
-    Supports:
-    - Standard connections (host:port)
-    - URL-based connections (redis://...)
-    - SSL/TLS for managed services (rediss://...)
-    - Sentinel for high availability
-    - Connection pooling
-    - Retry with exponential backoff
-    """
-
-    host: str = "localhost"
-    port: int = 6379
-    db: int = 0
-    password: str | None = None
-    use_mock: bool = False
-
-    # Security settings
-    pii_scrub_enabled: bool = True  # Scrub PII before storing (HIPAA/GDPR compliance)
-    secrets_detection_enabled: bool = True  # Block storage of detected secrets
-
-    # SSL/TLS settings
-    ssl: bool = False
-    ssl_cert_reqs: str | None = None  # "required", "optional", "none"
-    ssl_ca_certs: str | None = None
-    ssl_certfile: str | None = None
-    ssl_keyfile: str | None = None
-
-    # Connection pool settings
-    max_connections: int = 10
-    socket_timeout: float = 5.0
-    socket_connect_timeout: float = 5.0
-
-    # Retry settings
-    retry_on_timeout: bool = True
-    retry_max_attempts: int = 3
-    retry_base_delay: float = 0.1  # seconds
-    retry_max_delay: float = 2.0  # seconds
-
-    # Local LRU cache settings (two-tier caching)
-    local_cache_enabled: bool = True  # Enable local memory cache (reduces Redis network I/O)
-    local_cache_size: int = 500  # Maximum number of cached keys (~50KB memory)
-
-    # Sentinel settings (for HA)
-    sentinel_hosts: list[tuple[str, int]] | None = None
-    sentinel_master_name: str | None = None
-
-    def to_redis_kwargs(self) -> dict:
-        """Convert to redis.Redis constructor kwargs."""
-        kwargs: dict[str, Any] = {
-            "host": self.host,
-            "port": self.port,
-            "db": self.db,
-            "password": self.password,
-            "decode_responses": True,
-            "socket_timeout": self.socket_timeout,
-            "socket_connect_timeout": self.socket_connect_timeout,
-            "retry_on_timeout": self.retry_on_timeout,
-        }
-
-        if self.ssl:
-            kwargs["ssl"] = True
-            if self.ssl_cert_reqs:
-                kwargs["ssl_cert_reqs"] = self.ssl_cert_reqs
-            if self.ssl_ca_certs:
-                kwargs["ssl_ca_certs"] = self.ssl_ca_certs
-            if self.ssl_certfile:
-                kwargs["ssl_certfile"] = self.ssl_certfile
-            if self.ssl_keyfile:
-                kwargs["ssl_keyfile"] = self.ssl_keyfile
-
-        return kwargs
-
-
-@dataclass
-class RedisMetrics:
-    """Metrics for Redis operations."""
-
-    operations_total: int = 0
-    operations_success: int = 0
-    operations_failed: int = 0
-    retries_total: int = 0
-    latency_sum_ms: float = 0.0
-    latency_max_ms: float = 0.0
-
-    # Per-operation metrics
-    stash_count: int = 0
-    retrieve_count: int = 0
-    publish_count: int = 0
-    stream_append_count: int = 0
-
-    # Security metrics
-    pii_scrubbed_total: int = 0  # Total PII instances scrubbed
-    pii_scrub_operations: int = 0  # Operations that had PII scrubbed
-    secrets_blocked_total: int = 0  # Total secrets blocked from storage
-
-    def record_operation(self, operation: str, latency_ms: float, success: bool = True) -> None:
-        """Record an operation metric."""
-        self.operations_total += 1
-        self.latency_sum_ms += latency_ms
-        self.latency_max_ms = max(self.latency_max_ms, latency_ms)
-
-        if success:
-            self.operations_success += 1
-        else:
-            self.operations_failed += 1
-
-        # Track by operation type
-        if operation == "stash":
-            self.stash_count += 1
-        elif operation == "retrieve":
-            self.retrieve_count += 1
-        elif operation == "publish":
-            self.publish_count += 1
-        elif operation == "stream_append":
-            self.stream_append_count += 1
-
-    @property
-    def latency_avg_ms(self) -> float:
-        """Average latency in milliseconds."""
-        if self.operations_total == 0:
-            return 0.0
-        return self.latency_sum_ms / self.operations_total
-
-    @property
-    def success_rate(self) -> float:
-        """Success rate as percentage."""
-        if self.operations_total == 0:
-            return 100.0
-        return (self.operations_success / self.operations_total) * 100
-
-    def to_dict(self) -> dict:
-        """Convert metrics to dictionary for reporting and serialization.
-
-        Returns:
-            Dictionary with keys: operations_total, operations_success,
-            operations_failed, retries_total, latency_avg_ms, latency_max_ms,
-            success_rate, by_operation, security.
-        """
-        return {
-            "operations_total": self.operations_total,
-            "operations_success": self.operations_success,
-            "operations_failed": self.operations_failed,
-            "retries_total": self.retries_total,
-            "latency_avg_ms": round(self.latency_avg_ms, 2),
-            "latency_max_ms": round(self.latency_max_ms, 2),
-            "success_rate": round(self.success_rate, 2),
-            "by_operation": {
-                "stash": self.stash_count,
-                "retrieve": self.retrieve_count,
-                "publish": self.publish_count,
-                "stream_append": self.stream_append_count,
-            },
-            "security": {
-                "pii_scrubbed_total": self.pii_scrubbed_total,
-                "pii_scrub_operations": self.pii_scrub_operations,
-                "secrets_blocked_total": self.secrets_blocked_total,
-            },
-        }
-
-
-@dataclass
-class PaginatedResult:
-    """Result of a paginated query."""
-
-    items: list[Any]
-    cursor: str
-    has_more: bool
-    total_scanned: int = 0
-
-
-@dataclass
-class TimeWindowQuery:
-    """Query parameters for time-window operations."""
-
-    start_time: datetime | None = None
-    end_time: datetime | None = None
-    limit: int = 100
-    offset: int = 0
-
-    @property
-    def start_score(self) -> float:
-        """Start timestamp as Redis score."""
-        if self.start_time is None:
-            return float("-inf")
-        return self.start_time.timestamp()
-
-    @property
-    def end_score(self) -> float:
-        """End timestamp as Redis score."""
-        if self.end_time is None:
-            return float("+inf")
-        return self.end_time.timestamp()
-
-
-@dataclass
-class AgentCredentials:
-    """Agent identity and access permissions"""
-
-    agent_id: str
-    tier: AccessTier
-    roles: list[str] = field(default_factory=list)
-    created_at: datetime = field(default_factory=datetime.now)
-
-    def can_read(self) -> bool:
-        """All tiers can read"""
-        return True
-
-    def can_stage(self) -> bool:
-        """Contributor+ can stage patterns"""
-        return self.tier.value >= AccessTier.CONTRIBUTOR.value
-
-    def can_validate(self) -> bool:
-        """Validator+ can promote patterns"""
-        return self.tier.value >= AccessTier.VALIDATOR.value
-
-    def can_administer(self) -> bool:
-        """Only Stewards have full admin access"""
-        return self.tier.value >= AccessTier.STEWARD.value
-
-
-@dataclass
-class StagedPattern:
-    """Pattern awaiting validation"""
-
-    pattern_id: str
-    agent_id: str
-    pattern_type: str
-    name: str
-    description: str
-    code: str | None = None
-    context: dict = field(default_factory=dict)
-    confidence: float = 0.5
-    staged_at: datetime = field(default_factory=datetime.now)
-    interests: list[str] = field(default_factory=list)  # For negotiation
-
-    def __post_init__(self):
-        """Validate fields after initialization"""
-        # Pattern 1: String ID validation
-        if not self.pattern_id or not self.pattern_id.strip():
-            raise ValueError("pattern_id cannot be empty")
-        if not self.agent_id or not self.agent_id.strip():
-            raise ValueError("agent_id cannot be empty")
-        if not self.pattern_type or not self.pattern_type.strip():
-            raise ValueError("pattern_type cannot be empty")
-
-        # Pattern 4: Range validation for confidence
-        if not 0.0 <= self.confidence <= 1.0:
-            raise ValueError(f"confidence must be between 0.0 and 1.0, got {self.confidence}")
-
-        # Pattern 5: Type validation
-        if not isinstance(self.context, dict):
-            raise TypeError(f"context must be dict, got {type(self.context).__name__}")
-        if not isinstance(self.interests, list):
-            raise TypeError(f"interests must be list, got {type(self.interests).__name__}")
-
-    def to_dict(self) -> dict:
-        """Convert staged pattern to dictionary for serialization.
-
-        Returns:
-            Dictionary with keys: pattern_id, agent_id, pattern_type, name,
-            description, code, context, confidence, staged_at, interests.
-        """
-        return {
-            "pattern_id": self.pattern_id,
-            "agent_id": self.agent_id,
-            "pattern_type": self.pattern_type,
-            "name": self.name,
-            "description": self.description,
-            "code": self.code,
-            "context": self.context,
-            "confidence": self.confidence,
-            "staged_at": self.staged_at.isoformat(),
-            "interests": self.interests,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "StagedPattern":
-        """Reconstruct StagedPattern from dictionary.
-
-        Args:
-            data: Dictionary with required keys: pattern_id, agent_id,
-                pattern_type, name, description, staged_at.
-
-        Returns:
-            Reconstructed StagedPattern instance.
-
-        Raises:
-            KeyError: If required keys are missing.
-            ValueError: If data format is invalid.
-        """
-        return cls(
-            pattern_id=data["pattern_id"],
-            agent_id=data["agent_id"],
-            pattern_type=data["pattern_type"],
-            name=data["name"],
-            description=data["description"],
-            code=data.get("code"),
-            context=data.get("context", {}),
-            confidence=data.get("confidence", 0.5),
-            staged_at=datetime.fromisoformat(data["staged_at"]),
-            interests=data.get("interests", []),
-        )
-
-
-@dataclass
-class ConflictContext:
-    """Context for principled negotiation
-
-    Per Getting to Yes framework:
-    - Positions: What each party says they want
-    - Interests: Why they want it (underlying needs)
-    - BATNA: Best Alternative to Negotiated Agreement
-    """
-
-    conflict_id: str
-    positions: dict[str, Any]  # agent_id -> stated position
-    interests: dict[str, list[str]]  # agent_id -> underlying interests
-    batna: str | None = None  # Fallback strategy
-    created_at: datetime = field(default_factory=datetime.now)
-    resolved: bool = False
-    resolution: str | None = None
-
-    def to_dict(self) -> dict:
-        """Convert conflict context to dictionary for serialization.
-
-        Returns:
-            Dictionary with keys: conflict_id, positions, interests,
-            batna, created_at, resolved, resolution.
-        """
-        return {
-            "conflict_id": self.conflict_id,
-            "positions": self.positions,
-            "interests": self.interests,
-            "batna": self.batna,
-            "created_at": self.created_at.isoformat(),
-            "resolved": self.resolved,
-            "resolution": self.resolution,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "ConflictContext":
-        """Reconstruct ConflictContext from dictionary.
-
-        Args:
-            data: Dictionary with required keys: conflict_id, positions,
-                interests, created_at.
-
-        Returns:
-            Reconstructed ConflictContext instance.
-
-        Raises:
-            KeyError: If required keys are missing.
-            ValueError: If data format is invalid.
-        """
-        return cls(
-            conflict_id=data["conflict_id"],
-            positions=data["positions"],
-            interests=data["interests"],
-            batna=data.get("batna"),
-            created_at=datetime.fromisoformat(data["created_at"]),
-            resolved=data.get("resolved", False),
-            resolution=data.get("resolution"),
-        )
-
-
-class SecurityError(Exception):
-    """Raised when a security policy is violated (e.g., secrets detected in data)."""
-
-
-__all__ = [
-    "AccessTier",
-    "AgentCredentials",
-    "ConflictContext",
-    "PaginatedResult",
-    "RedisConfig",
-    "RedisMetrics",
-    "SecurityError",
-    "StagedPattern",
-    "TTLStrategy",
-    "TimeWindowQuery",
-]

empathy_os/memory/unified.py

@@ -1,182 +0,0 @@
-"""Unified Memory Interface for Empathy Framework
-
-Provides a single API for both short-term (Redis) and long-term (persistent) memory,
-with automatic pattern promotion and environment-aware storage backend selection.
-
-Usage:
-    from empathy_os.memory import UnifiedMemory
-
-    memory = UnifiedMemory(
-        user_id="agent@company.com",
-        environment="production",  # or "staging", "development"
-    )
-
-    # Short-term operations
-    memory.stash("working_data", {"key": "value"})
-    data = memory.retrieve("working_data")
-
-    # Long-term operations
-    result = memory.persist_pattern(content, pattern_type="algorithm")
-    pattern = memory.recall_pattern(pattern_id)
-
-    # Pattern promotion
-    memory.promote_pattern(staged_pattern_id)
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import os
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any
-
-import structlog
-
-from .file_session import FileSessionMemory
-from .long_term import LongTermMemory, SecureMemDocsIntegration
-from .mixins import (
-    BackendInitMixin,
-    CapabilitiesMixin,
-    HandoffAndExportMixin,
-    LifecycleMixin,
-    LongTermOperationsMixin,
-    PatternPromotionMixin,
-    ShortTermOperationsMixin,
-)
-from .redis_bootstrap import RedisStatus
-from .short_term import (
-    AccessTier,
-    RedisShortTermMemory,
-)
-
-logger = structlog.get_logger(__name__)
-
-
-class Environment(Enum):
-    """Deployment environment for storage configuration."""
-
-    DEVELOPMENT = "development"
-    STAGING = "staging"
-    PRODUCTION = "production"
-
-
-@dataclass
-class MemoryConfig:
-    """Configuration for unified memory system."""
-
-    # Environment
-    environment: Environment = Environment.DEVELOPMENT
-
-    # File-first architecture settings (always available)
-    file_session_enabled: bool = True  # Use file-based session as primary
-    file_session_dir: str = ".empathy"  # Directory for file-based storage
-
-    # Short-term memory settings (Redis - optional enhancement)
-    redis_url: str | None = None
-    redis_host: str = "localhost"
-    redis_port: int = 6379
-    redis_mock: bool = False
-    redis_auto_start: bool = False  # Changed to False - file-first by default
-    redis_required: bool = False  # If True, fail without Redis
-    default_ttl_seconds: int = 3600  # 1 hour
-
-    # Long-term memory settings
-    storage_dir: str = "./memdocs_storage"
-    encryption_enabled: bool = True
-
-    # Claude memory settings
-    claude_memory_enabled: bool = True
-    load_enterprise_memory: bool = True
-    load_project_memory: bool = True
-    load_user_memory: bool = True
-
-    # Pattern promotion settings
-    auto_promote_threshold: float = 0.8  # Confidence threshold for auto-promotion
-
-    # Compact state auto-generation
-    auto_generate_compact_state: bool = True
-    compact_state_path: str = ".claude/compact-state.md"
-
-    @classmethod
-    def from_environment(cls) -> "MemoryConfig":
-        """Create configuration from environment variables.
-
-        Environment Variables:
-            EMPATHY_ENV: Environment (development/staging/production)
-            EMPATHY_FILE_SESSION: Enable file-based session (true/false, default: true)
-            EMPATHY_FILE_SESSION_DIR: Directory for file-based storage
-            REDIS_URL: Redis connection URL
-            EMPATHY_REDIS_MOCK: Use mock Redis (true/false)
-            EMPATHY_REDIS_AUTO_START: Auto-start Redis (true/false, default: false)
-            EMPATHY_REDIS_REQUIRED: Fail without Redis (true/false, default: false)
-            EMPATHY_STORAGE_DIR: Long-term storage directory
-            EMPATHY_ENCRYPTION: Enable encryption (true/false)
-        """
-        env_str = os.getenv("EMPATHY_ENV", "development").lower()
-        environment = (
-            Environment(env_str)
-            if env_str in [e.value for e in Environment]
-            else Environment.DEVELOPMENT
-        )
-
-        return cls(
-            environment=environment,
-            # File-first settings (always available)
-            file_session_enabled=os.getenv("EMPATHY_FILE_SESSION", "true").lower() == "true",
-            file_session_dir=os.getenv("EMPATHY_FILE_SESSION_DIR", ".empathy"),
-            # Redis settings (optional)
-            redis_url=os.getenv("REDIS_URL"),
-            redis_host=os.getenv("EMPATHY_REDIS_HOST", "localhost"),
-            redis_port=int(os.getenv("EMPATHY_REDIS_PORT", "6379")),
-            redis_mock=os.getenv("EMPATHY_REDIS_MOCK", "").lower() == "true",
-            redis_auto_start=os.getenv("EMPATHY_REDIS_AUTO_START", "false").lower() == "true",
-            redis_required=os.getenv("EMPATHY_REDIS_REQUIRED", "false").lower() == "true",
-            # Long-term storage
-            storage_dir=os.getenv("EMPATHY_STORAGE_DIR", "./memdocs_storage"),
-            encryption_enabled=os.getenv("EMPATHY_ENCRYPTION", "true").lower() == "true",
-            claude_memory_enabled=os.getenv("EMPATHY_CLAUDE_MEMORY", "true").lower() == "true",
-            # Compact state
-            auto_generate_compact_state=os.getenv("EMPATHY_AUTO_COMPACT_STATE", "true").lower()
-            == "true",
-            compact_state_path=os.getenv("EMPATHY_COMPACT_STATE_PATH", ".claude/compact-state.md"),
-        )
-
-
-@dataclass
-class UnifiedMemory(
-    BackendInitMixin,
-    ShortTermOperationsMixin,
-    LongTermOperationsMixin,
-    PatternPromotionMixin,
-    CapabilitiesMixin,
-    HandoffAndExportMixin,
-    LifecycleMixin,
-):
-    """Unified interface for short-term and long-term memory.
-
-    Provides:
-    - Short-term memory (Redis): Fast, TTL-based working memory
-    - Long-term memory (Persistent): Cross-session pattern storage
-    - Pattern promotion: Move validated patterns from short to long-term
-    - Environment-aware configuration: Auto-detect storage backends
-    """
-
-    user_id: str
-    config: MemoryConfig = field(default_factory=MemoryConfig.from_environment)
-    access_tier: AccessTier = AccessTier.CONTRIBUTOR
-
-    # Internal state
-    _file_session: FileSessionMemory | None = field(default=None, init=False)  # Primary storage
-    _short_term: RedisShortTermMemory | None = field(default=None, init=False)  # Optional Redis
-    _long_term: SecureMemDocsIntegration | None = field(default=None, init=False)
-    _simple_long_term: LongTermMemory | None = field(default=None, init=False)
-    _redis_status: RedisStatus | None = field(default=None, init=False)
-    _initialized: bool = field(default=False, init=False)
-    # LRU cache for pattern lookups (pattern_id -> pattern_data)
-    _pattern_cache: dict[str, dict[str, Any]] = field(default_factory=dict, init=False)
-    _pattern_cache_max_size: int = field(default=100, init=False)
-
-    def __post_init__(self):
-        """Initialize memory backends based on configuration."""
-        self._initialize_backends()

empathy_os/meta_workflows/__init__.py

@@ -1,74 +0,0 @@
-"""Meta-workflow system for dynamic agent team generation.
-
-This package provides:
-- Socratic form engine for requirements gathering
-- Dynamic agent generation from templates
-- Pattern learning from historical executions
-- Template registry for reusable workflows
-
-Created: 2026-01-17
-Version: 1.0.0 (experimental)
-"""
-
-from empathy_os.meta_workflows.agent_creator import DynamicAgentCreator
-from empathy_os.meta_workflows.form_engine import SocraticFormEngine
-from empathy_os.meta_workflows.intent_detector import (
-    IntentDetector,
-    IntentMatch,
-    auto_detect_template,
-    detect_and_suggest,
-)
-from empathy_os.meta_workflows.models import (
-    AgentCompositionRule,
-    AgentExecutionResult,
-    AgentSpec,
-    FormQuestion,
-    FormResponse,
-    FormSchema,
-    MetaWorkflowResult,
-    MetaWorkflowTemplate,
-    PatternInsight,
-    QuestionType,
-    TierStrategy,
-)
-from empathy_os.meta_workflows.pattern_learner import PatternLearner
-from empathy_os.meta_workflows.template_registry import TemplateRegistry
-from empathy_os.meta_workflows.workflow import (
-    MetaWorkflow,
-    list_execution_results,
-    load_execution_result,
-)
-
-__version__ = "1.0.0"
-
-__all__ = [
-    # Enums
-    "QuestionType",
-    "TierStrategy",
-    # Form components
-    "FormQuestion",
-    "FormSchema",
-    "FormResponse",
-    "SocraticFormEngine",
-    # Agent components
-    "AgentCompositionRule",
-    "AgentSpec",
-    "AgentExecutionResult",
-    "DynamicAgentCreator",
-    # Meta-workflow components
-    "MetaWorkflowTemplate",
-    "MetaWorkflowResult",
-    "TemplateRegistry",
-    "MetaWorkflow",
-    # Helpers
-    "list_execution_results",
-    "load_execution_result",
-    # Analytics
-    "PatternInsight",
-    "PatternLearner",
-    # Intent detection
-    "IntentDetector",
-    "IntentMatch",
-    "auto_detect_template",
-    "detect_and_suggest",
-]