attune-ai 2.0.0__py3-none-any.whl

attune/memory/mixins/promotion_mixin.py

@@ -0,0 +1,109 @@
+"""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

attune/memory/mixins/short_term_mixin.py

@@ -0,0 +1,182 @@
+"""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]

attune/memory/nodes.py

@@ -0,0 +1,179 @@
+"""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