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

empathy_os/memory/mixins/promotion_mixin.py

@@ -1,109 +0,0 @@
-"""Pattern promotion mixin for UnifiedMemory.
-
-Handles promotion of patterns from short-term to long-term memory.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from typing import TYPE_CHECKING, Any
-
-import structlog
-
-if TYPE_CHECKING:
-    from ..long_term import Classification
-    from ..short_term import AgentCredentials, RedisShortTermMemory
-
-logger = structlog.get_logger(__name__)
-
-
-class PatternPromotionMixin:
-    """Mixin providing pattern promotion capabilities for UnifiedMemory."""
-
-    # Type hints for attributes that will be provided by UnifiedMemory
-    _short_term: "RedisShortTermMemory | None"
-    _long_term: Any  # SecureMemDocsIntegration | None
-
-    # Needs access to methods from other mixins
-    @property
-    def credentials(self) -> "AgentCredentials":
-        """Get credentials - provided by ShortTermOperationsMixin."""
-        ...
-
-    def get_staged_patterns(self) -> list[dict]:
-        """Get staged patterns - provided by ShortTermOperationsMixin."""
-        ...
-
-    def persist_pattern(
-        self,
-        content: str,
-        pattern_type: str,
-        classification: "Classification | str | None" = None,
-        auto_classify: bool = True,
-        metadata: dict[str, Any] | None = None,
-    ) -> dict[str, Any] | None:
-        """Persist pattern - provided by LongTermOperationsMixin."""
-        ...
-
-    # =========================================================================
-    # PATTERN PROMOTION (SHORT-TERM → LONG-TERM)
-    # =========================================================================
-
-    def promote_pattern(
-        self,
-        staged_pattern_id: str,
-        classification: "Classification | str | None" = None,
-        auto_classify: bool = True,
-    ) -> dict[str, Any] | None:
-        """Promote a staged pattern from short-term to long-term memory.
-
-        Args:
-            staged_pattern_id: ID of staged pattern to promote
-            classification: Override classification (or auto-detect)
-            auto_classify: Auto-detect classification from content
-
-        Returns:
-            Long-term storage result, or None if failed
-
-        """
-        if not self._short_term or not self._long_term:
-            logger.error("memory_backends_unavailable")
-            return None
-
-        # Retrieve staged pattern
-        staged_patterns = self.get_staged_patterns()
-        staged = next(
-            (p for p in staged_patterns if p.get("pattern_id") == staged_pattern_id),
-            None,
-        )
-
-        if not staged:
-            logger.warning("staged_pattern_not_found", pattern_id=staged_pattern_id)
-            return None
-
-        # Persist to long-term storage
-        # Content is stored in context dict by stage_pattern
-        context = staged.get("context", {})
-        content = context.get("content", "") or staged.get("description", "")
-        result = self.persist_pattern(
-            content=content,
-            pattern_type=staged.get("pattern_type", "general"),
-            classification=classification,
-            auto_classify=auto_classify,
-            metadata=context,
-        )
-
-        if result:
-            # Remove from staging (use promote_pattern which handles deletion)
-            try:
-                self._short_term.promote_pattern(staged_pattern_id, self.credentials)
-            except PermissionError:
-                # If we can't promote (delete from staging), just log it
-                logger.warning("could_not_remove_from_staging", pattern_id=staged_pattern_id)
-            logger.info(
-                "pattern_promoted",
-                staged_id=staged_pattern_id,
-                long_term_id=result.get("pattern_id"),
-            )
-
-        return result

empathy_os/memory/mixins/short_term_mixin.py

@@ -1,182 +0,0 @@
-"""Short-term memory operations mixin for UnifiedMemory.
-
-Provides working memory operations (stash/retrieve) and pattern staging.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import uuid
-from datetime import datetime
-from typing import TYPE_CHECKING, Any
-
-import structlog
-
-if TYPE_CHECKING:
-    from ..file_session import FileSessionMemory
-    from ..redis_bootstrap import RedisStatus
-    from ..short_term import (
-        AccessTier,
-        AgentCredentials,
-        RedisShortTermMemory,
-    )
-
-logger = structlog.get_logger(__name__)
-
-
-class ShortTermOperationsMixin:
-    """Mixin providing short-term memory operations for UnifiedMemory."""
-
-    # Type hints for attributes that will be provided by UnifiedMemory
-    user_id: str
-    access_tier: "AccessTier"
-    _file_session: "FileSessionMemory | None"
-    _short_term: "RedisShortTermMemory | None"
-    _redis_status: "RedisStatus | None"
-    config: Any  # MemoryConfig
-
-    @property
-    def credentials(self) -> "AgentCredentials":
-        """Get agent credentials for short-term memory operations."""
-        from ..short_term import AgentCredentials
-
-        return AgentCredentials(agent_id=self.user_id, tier=self.access_tier)
-
-    # =========================================================================
-    # SHORT-TERM MEMORY OPERATIONS (Working Memory)
-    # =========================================================================
-
-    def stash(self, key: str, value: Any, ttl_seconds: int | None = None) -> bool:
-        """Store data in working memory with TTL.
-
-        Uses file-based session as primary storage, with optional Redis for
-        real-time features. Data is persisted to disk automatically.
-
-        Args:
-            key: Storage key
-            value: Data to store (must be JSON-serializable)
-            ttl_seconds: Time-to-live in seconds (default from config)
-
-        Returns:
-            True if stored successfully
-
-        """
-        from ..short_term import TTLStrategy
-
-        ttl = ttl_seconds or self.config.default_ttl_seconds
-
-        # Primary: File session memory (always available)
-        if self._file_session:
-            self._file_session.stash(key, value, ttl=ttl)
-
-        # Optional: Redis for real-time sync
-        if self._short_term and self._redis_status and self._redis_status.available:
-            # Map ttl_seconds to TTLStrategy
-            ttl_strategy = TTLStrategy.WORKING_RESULTS
-            if ttl_seconds is not None:
-                # COORDINATION removed in v5.0 - use SESSION for short-lived data
-                if ttl_seconds <= TTLStrategy.SESSION.value:
-                    ttl_strategy = TTLStrategy.SESSION
-                elif ttl_seconds <= TTLStrategy.WORKING_RESULTS.value:
-                    ttl_strategy = TTLStrategy.WORKING_RESULTS
-                elif ttl_seconds <= TTLStrategy.STAGED_PATTERNS.value:
-                    ttl_strategy = TTLStrategy.STAGED_PATTERNS
-                else:
-                    ttl_strategy = TTLStrategy.CONFLICT_CONTEXT
-
-            try:
-                self._short_term.stash(key, value, self.credentials, ttl_strategy)
-            except Exception as e:
-                logger.debug("redis_stash_failed", key=key, error=str(e))
-
-        # Return True if at least one backend succeeded
-        return self._file_session is not None
-
-    def retrieve(self, key: str) -> Any | None:
-        """Retrieve data from working memory.
-
-        Checks Redis first (if available) for faster access, then falls back
-        to file-based session storage.
-
-        Args:
-            key: Storage key
-
-        Returns:
-            Stored data or None if not found
-
-        """
-        # Try Redis first (faster, if available)
-        if self._short_term and self._redis_status and self._redis_status.available:
-            try:
-                result = self._short_term.retrieve(key, self.credentials)
-                if result is not None:
-                    return result
-            except Exception as e:
-                logger.debug("redis_retrieve_failed", key=key, error=str(e))
-
-        # Fall back to file session (primary storage)
-        if self._file_session:
-            return self._file_session.retrieve(key)
-
-        return None
-
-    # =========================================================================
-    # PATTERN STAGING
-    # =========================================================================
-
-    def stage_pattern(
-        self,
-        pattern_data: dict[str, Any],
-        pattern_type: str = "general",
-        ttl_hours: int = 24,
-    ) -> str | None:
-        """Stage a pattern for validation before long-term storage.
-
-        Args:
-            pattern_data: Pattern content and metadata
-            pattern_type: Type of pattern (algorithm, protocol, etc.)
-            ttl_hours: Hours before staged pattern expires (not used in current impl)
-
-        Returns:
-            Staged pattern ID or None if failed
-
-        """
-        from ..short_term import StagedPattern
-
-        if not self._short_term:
-            logger.warning("short_term_memory_unavailable")
-            return None
-
-        # Create a StagedPattern object from the pattern_data dict
-        pattern_id = f"staged_{uuid.uuid4().hex[:12]}"
-        staged_pattern = StagedPattern(
-            pattern_id=pattern_id,
-            agent_id=self.user_id,
-            pattern_type=pattern_type,
-            name=pattern_data.get("name", f"Pattern {pattern_id[:8]}"),
-            description=pattern_data.get("description", ""),
-            code=pattern_data.get("code"),
-            context=pattern_data.get("context", {}),
-            confidence=pattern_data.get("confidence", 0.5),
-            staged_at=datetime.now(),
-            interests=pattern_data.get("interests", []),
-        )
-        # Store content in context if provided
-        if "content" in pattern_data:
-            staged_pattern.context["content"] = pattern_data["content"]
-
-        success = self._short_term.stage_pattern(staged_pattern, self.credentials)
-        return pattern_id if success else None
-
-    def get_staged_patterns(self) -> list[dict]:
-        """Get all staged patterns awaiting validation.
-
-        Returns:
-            List of staged patterns with metadata
-
-        """
-        if not self._short_term:
-            return []
-
-        staged_list = self._short_term.list_staged_patterns(self.credentials)
-        return [p.to_dict() for p in staged_list]

empathy_os/memory/nodes.py

@@ -1,179 +0,0 @@
-"""Memory Graph Node Types
-
-Defines node types for the cross-workflow knowledge graph.
-Each node represents an entity discovered by a workflow.
-
-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 NodeType(Enum):
-    """Types of nodes in the memory graph."""
-
-    # Code entities
-    FILE = "file"
-    FUNCTION = "function"
-    CLASS = "class"
-    MODULE = "module"
-
-    # Issues and findings
-    BUG = "bug"
-    VULNERABILITY = "vulnerability"
-    PERFORMANCE_ISSUE = "performance_issue"
-    CODE_SMELL = "code_smell"
-    TECH_DEBT = "tech_debt"
-
-    # Solutions and patterns
-    PATTERN = "pattern"
-    FIX = "fix"
-    REFACTOR = "refactor"
-
-    # Testing
-    TEST = "test"
-    TEST_CASE = "test_case"
-    COVERAGE_GAP = "coverage_gap"
-
-    # Documentation
-    DOC = "doc"
-    API_ENDPOINT = "api_endpoint"
-
-    # Dependencies
-    DEPENDENCY = "dependency"
-    LICENSE = "license"
-
-
-@dataclass
-class Node:
-    """A node in the memory graph.
-
-    Represents any entity that workflows discover or create.
-    """
-
-    id: str
-    type: NodeType
-    name: str
-    description: str = ""
-
-    # Where this node came from
-    source_workflow: str = ""
-    source_file: str = ""
-    source_line: int | None = None
-
-    # Classification
-    severity: str = ""  # critical, high, medium, low, info
-    confidence: float = 1.0  # 0.0 - 1.0
-
-    # Metadata
-    metadata: dict[str, Any] = field(default_factory=dict)
-    tags: list[str] = field(default_factory=list)
-
-    # Timestamps
-    created_at: datetime = field(default_factory=datetime.now)
-    updated_at: datetime = field(default_factory=datetime.now)
-
-    # Status tracking
-    status: str = "open"  # open, investigating, resolved, wontfix
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert node to dictionary for JSON serialization."""
-        return {
-            "id": self.id,
-            "type": self.type.value,
-            "name": self.name,
-            "description": self.description,
-            "source_workflow": self.source_workflow,
-            "source_file": self.source_file,
-            "source_line": self.source_line,
-            "severity": self.severity,
-            "confidence": self.confidence,
-            "metadata": self.metadata,
-            "tags": self.tags,
-            "created_at": self.created_at.isoformat(),
-            "updated_at": self.updated_at.isoformat(),
-            "status": self.status,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "Node":
-        """Create node from dictionary."""
-        return cls(
-            id=data["id"],
-            type=NodeType(data["type"]),
-            name=data["name"],
-            description=data.get("description", ""),
-            source_workflow=data.get("source_workflow", data.get("source_wizard", "")),
-            source_file=data.get("source_file", ""),
-            source_line=data.get("source_line"),
-            severity=data.get("severity", ""),
-            confidence=data.get("confidence", 1.0),
-            metadata=data.get("metadata", {}),
-            tags=data.get("tags", []),
-            created_at=(
-                datetime.fromisoformat(data["created_at"])
-                if "created_at" in data
-                else datetime.now()
-            ),
-            updated_at=(
-                datetime.fromisoformat(data["updated_at"])
-                if "updated_at" in data
-                else datetime.now()
-            ),
-            status=data.get("status", "open"),
-        )
-
-
-@dataclass
-class BugNode(Node):
-    """Specialized node for bugs."""
-
-    root_cause: str = ""
-    fix_suggestion: str = ""
-    reproduction_steps: list[str] = field(default_factory=list)
-
-    def __post_init__(self):
-        self.type = NodeType.BUG
-
-
-@dataclass
-class VulnerabilityNode(Node):
-    """Specialized node for security vulnerabilities."""
-
-    cwe_id: str = ""
-    cvss_score: float = 0.0
-    attack_vector: str = ""
-    remediation: str = ""
-
-    def __post_init__(self):
-        self.type = NodeType.VULNERABILITY
-
-
-@dataclass
-class PerformanceNode(Node):
-    """Specialized node for performance issues."""
-
-    metric: str = ""  # latency, memory, cpu, etc.
-    current_value: float = 0.0
-    target_value: float = 0.0
-    optimization_suggestion: str = ""
-
-    def __post_init__(self):
-        self.type = NodeType.PERFORMANCE_ISSUE
-
-
-@dataclass
-class PatternNode(Node):
-    """Specialized node for code patterns."""
-
-    pattern_type: str = ""  # anti-pattern, best-practice, idiom
-    language: str = ""
-    example_code: str = ""
-    applies_to: list[str] = field(default_factory=list)
-
-    def __post_init__(self):
-        self.type = NodeType.PATTERN