noesium 0.1.0__py3-none-any.whl

noesium/core/memory/memu/memory/actions/add_activity_memory.py

@@ -0,0 +1,299 @@
+"""
+Add Activity Memory Action
+
+Adds new activity memory content with strict no-pronouns formatting, following the same
+high-quality standards as update_memory_with_suggestions for self-contained memory items.
+"""
+
+import json
+import logging
+from datetime import datetime
+from typing import Any, Dict
+
+from .base_action import BaseAction
+
+logger = logging.getLogger(__name__)
+
+
+class AddActivityMemoryAction(BaseAction):
+    """
+    Action to add new activity memory content with strict formatting requirements
+
+    Ensures all memory items are complete, self-contained sentences with no pronouns,
+    following the same standards as update_memory_with_suggestions.
+    """
+
+    @property
+    def action_name(self) -> str:
+        return "add_activity_memory"
+
+    def get_schema(self) -> Dict[str, Any]:
+        """Return OpenAI-compatible function schema"""
+        return {
+            "name": "add_activity_memory",
+            "description": "Add new activity memory content with strict no-pronouns formatting for complete, self-contained memory items",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "character_name": {
+                        "type": "string",
+                        "description": "Name of the character",
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "Complete original conversation text exactly as provided - do NOT modify, extract, or summarize",
+                    },
+                    "session_date": {
+                        "type": "string",
+                        "description": "Date of the session (e.g., '2024-01-15')",
+                        "default": None,
+                    },
+                    "generate_embeddings": {
+                        "type": "boolean",
+                        "description": "Whether to generate embeddings for semantic search",
+                        "default": True,
+                    },
+                },
+                "required": ["character_name", "content"],
+            },
+        }
+
+    def execute(
+        self,
+        character_name: str,
+        content: str,
+        session_date: str = None,
+        generate_embeddings: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Execute add activity memory operation with strict formatting
+
+        Args:
+            character_name: Name of the character
+            content: Raw content to process and format
+            session_date: Date of the session
+            generate_embeddings: Whether to generate embeddings for the content
+
+        Returns:
+            Dict containing operation result including formatted content and embedding info
+        """
+        try:
+            # Use current date if not provided
+            if not session_date:
+                session_date = datetime.now().strftime("%Y-%m-%d")
+
+            # Process raw content through LLM to ensure strict formatting
+            formatted_content = self._format_content_with_llm(character_name, content, session_date)
+
+            if not formatted_content.strip():
+                return self._add_metadata({"success": False, "error": "LLM returned empty formatted content"})
+
+            # Add memory IDs with timestamp to the formatted content
+            memory_items, content_with_ids = self._add_memory_ids_with_timestamp(formatted_content, session_date)
+
+            # Save first, then add embedding for just the new content
+            success = self._append_memory_content(character_name, "activity", content_with_ids)
+
+            # Save content with embeddings if enabled
+            if success and generate_embeddings and self.embeddings_enabled:
+                self._add_memory_item_embedding(character_name, "activity", memory_items)
+
+            if success:
+                return self._add_metadata(
+                    {
+                        "success": True,
+                        "character_name": character_name,
+                        "category": "activity",
+                        "session_date": session_date,
+                        "memory_items_added": len(memory_items),
+                        "memory_items": memory_items,
+                        "message": f"Successfully generated {len(memory_items)} self-contained activity memory items for {character_name}",
+                    }
+                )
+            else:
+                return self._add_metadata({"success": False, "error": "Failed to save activity memory"})
+
+        except Exception as e:
+            return self._handle_error(e)
+
+    def _format_content_with_llm(self, character_name: str, content: str, session_date: str) -> str:
+        """Use LLM to format content with meaningful activity grouping"""
+
+        user_name = character_name
+
+        # Create enhanced prompt for meaningful activity grouping
+        format_prompt = f"""You are formatting activity memory content for {user_name} on {session_date}.
+
+Raw content to format:
+{content}
+
+**CRITICAL REQUIREMENT: GROUP RELATED CONTENT INTO MEANINGFUL ACTIVITIES**
+
+Transform this raw content into properly formatted activity memory items following these rules:
+
+**MEANINGFUL ACTIVITY GROUPING REQUIREMENTS:**
+- Group related sentences/statements into single, comprehensive activity descriptions
+- Each activity should be a complete, self-contained description of what happened
+- Combine related dialogue, actions, and context into cohesive activity blocks
+- Only create separate items for genuinely different activities or topics
+- Each activity item should tell a complete "story" or "event"
+
+**SELF-CONTAINED MEMORY REQUIREMENTS:**
+- EVERY activity item must be complete and standalone
+- ALWAYS include the full subject (do not use "she/he/they/it")
+- NEVER use pronouns that depend on context (no "she", "he", "they", "it")
+- Include specific names, places, dates, and full context in each item
+- Each activity should be understandable without reading other items
+- Include all relevant details, emotions, and outcomes in the activity description
+
+**FORMAT REQUIREMENTS:**
+1. Each line = one complete, meaningful activity (may include multiple related sentences)
+2. NO markdown headers, bullets, numbers, or structure
+3. Write in plain text only
+4. Focus on comprehensive, meaningful activity descriptions
+5. Use specific names, titles, places, and dates
+6. Each line ends with a period
+
+**GOOD EXAMPLES (meaningful activities, one per line):**
+{character_name} attended a LGBTQ support group where {character_name} heard inspiring transgender stories and felt happy, thankful, accepted, and gained courage to embrace {character_name}'s true self.
+{character_name} discussed future career plans with Melanie, expressing keen interest in counseling and mental health work to support people with similar issues, and Melanie encouraged {character_name} saying {character_name} would be a great counselor due to {character_name}'s empathy and understanding.
+{character_name} admired Melanie's lake sunrise painting from last year, complimented the color blending, and discussed how painting serves as a great outlet for expressing feelings and relaxing after long days.
+
+**BAD EXAMPLES (too fragmented):**
+{character_name} went to a LGBTQ support group.
+{character_name} heard transgender stories.
+{character_name} felt happy and thankful.
+{character_name} gained courage to embrace {character_name}'s true self.
+
+**ACTIVITY GROUPING GUIDELINES:**
+- Conversations about the same topic → Single activity
+- Related actions and their outcomes → Single activity
+- Emotional reactions to specific events → Include in the main activity
+- Sequential related events → Single comprehensive activity
+- Different topics or unrelated events → Separate activities
+
+**QUALITY STANDARDS:**
+- Never use "he", "she", "they", "it" - always use the person's actual name
+- Never use "the book", "the place", "the friend" - always include full titles and names
+- Each activity must be complete and tell the full story
+- Include emotional context, outcomes, and significance
+- Merge related content intelligently to create meaningful activity summaries
+
+Transform the raw content into properly formatted activity memory items (ONE MEANINGFUL ACTIVITY PER LINE):
+
+"""
+
+        # Call LLM to format content
+        cleaned_content = self.llm_client.simple_chat(format_prompt)
+
+        return cleaned_content
+
+    def _add_memory_ids_with_timestamp(self, content: str, session_date: str) -> tuple[list[dict], str]:
+        """
+        Add memory IDs with timestamp to content lines
+        Format: [memory_id][mentioned at {session_date}] {content}
+
+        Args:
+            content: Raw content
+            session_date: Date of the session
+
+        Returns:
+            Content with memory IDs and timestamps added to each line
+        """
+        if not content.strip():
+            return content
+
+        lines = content.split("\n")
+        processed_items = []
+        plain_memory_lines = []
+
+        for line in lines:
+            line = line.strip()
+            if line:  # Only process non-empty lines
+                # Generate new unique memory ID for this line
+                memory_id = self._generate_memory_id()
+                # Format: [memory_id][mentioned at {session_date}] {content} [links]
+                processed_items.append(
+                    {
+                        "memory_id": memory_id,
+                        "mentioned_at": session_date,
+                        "content": line,
+                        "links": "",
+                    }
+                )
+                plain_memory_lines.append(f"[{memory_id}][mentioned at {session_date}] {line} []")
+
+        plain_memory_text = "\n".join(plain_memory_lines)
+
+        return processed_items, plain_memory_text
+
+    def _add_memory_item_embedding(self, character_name: str, category: str, new_items: list[dict]) -> Dict[str, Any]:
+        """Add embedding for new memory items"""
+        try:
+            if not self.embeddings_enabled or not new_items:
+                return {"success": False, "error": "Embeddings disabled or empty item"}
+
+            # Get character embeddings directory from storage manager
+            char_embeddings_dir = self.storage_manager.get_char_embeddings_dir()
+            embeddings_file = char_embeddings_dir / f"{category}_embeddings.json"
+
+            existing_embeddings = []
+            if embeddings_file.exists():
+                with open(embeddings_file, "r", encoding="utf-8") as f:
+                    embeddings_data = json.load(f)
+                    existing_embeddings = embeddings_data.get("embeddings", [])
+
+            # Generate embeddings for new items
+            for item in new_items:
+                if not item["content"].strip():
+                    continue
+
+                try:
+                    embedding_vector = self.embedding_client.embed(item["content"])
+
+                    new_item_id = f"{character_name}_{category}_item_{len(existing_embeddings)}"
+
+                    new_embedding = {
+                        "item_id": new_item_id,
+                        "memory_id": item["memory_id"],
+                        "text": item["content"],
+                        "full_line": f"[{item['memory_id']}][mentioned at {item['mentioned_at']}] {item['content']} [{item['links']}]",
+                        "embedding": embedding_vector,
+                        "line_number": len(existing_embeddings) + 1,
+                        "metadata": {
+                            "character": character_name,
+                            "category": category,
+                            "length": len(item["content"]),
+                            "mentioned_at": item["mentioned_at"],
+                            "timestamp": datetime.now().isoformat(),
+                        },
+                    }
+
+                    # Add to existing embeddings
+                    existing_embeddings.append(new_embedding)
+
+                except Exception as e:
+                    logger.warning(f"Failed to generate embedding for memory item {item.get('memory_id')}: {repr(e)}")
+                    continue
+
+            # Save updated embeddings
+            embeddings_data = {
+                "category": category,
+                "timestamp": datetime.now().isoformat(),
+                "embeddings": existing_embeddings,
+                "total_embeddings": len(existing_embeddings),
+            }
+
+            with open(embeddings_file, "w", encoding="utf-8") as f:
+                json.dump(embeddings_data, f, indent=2, ensure_ascii=False)
+
+            return {
+                "success": True,
+                "embedding_count": len(existing_embeddings),
+                "new_items_count": len(new_items),
+                "message": f"Added embeddings for {len(new_items)} new memory items in {category}",
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to add memory item embedding: {e}")
+            return {"success": False, "error": str(e)}

noesium/core/memory/memu/memory/actions/base_action.py

@@ -0,0 +1,342 @@
+"""
+Base Action Class for Memory Operations
+
+Defines the interface and common functionality for all memory actions.
+"""
+
+import logging
+import re
+import uuid
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import Any, Dict, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class BaseAction(ABC):
+    """
+    Base class for all memory actions
+
+    Defines the standard interface that all actions must implement:
+    - get_schema(): Return OpenAI-compatible function schema
+    - execute(**kwargs): Execute the action with given arguments
+    - validate_arguments(): Validate input arguments
+    """
+
+    def __init__(self, memory_core):
+        """
+        Initialize action with memory core
+
+        Args:
+            memory_core: Core memory functionality (file manager, embeddings, config, etc.)
+        """
+        self.memory_core = memory_core
+        self.llm_client = memory_core.llm_client
+        self.storage_manager = memory_core.storage_manager
+        self.embedding_client = memory_core.embedding_client
+        self.embeddings_enabled = memory_core.embeddings_enabled
+        self.config_manager = memory_core.config_manager
+        self.memory_types = memory_core.memory_types
+        self.basic_memory_types = memory_core.memory_types["basic"]
+        self.processing_order = memory_core.processing_order
+        # self.embeddings_dir = memory_core.embeddings_dir
+
+    @property
+    @abstractmethod
+    def action_name(self) -> str:
+        """Return the name of this action"""
+
+    @abstractmethod
+    def get_schema(self) -> Dict[str, Any]:
+        """
+        Return OpenAI-compatible function schema for this action
+
+        Returns:
+            Dict containing function schema with name, description, and parameters
+        """
+
+    @abstractmethod
+    def execute(self, **kwargs) -> Dict[str, Any]:
+        """
+        Execute the action with provided arguments
+
+        Args:
+            **kwargs: Action-specific arguments
+
+        Returns:
+            Dict containing execution result with success status and data
+        """
+
+    def validate_arguments(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate input arguments against schema
+
+        Args:
+            arguments: Arguments to validate
+
+        Returns:
+            Dict with validation result
+        """
+        try:
+            schema = self.get_schema()
+            required_params = schema["parameters"].get("required", [])
+
+            # Check for missing required parameters
+            missing_params = [param for param in required_params if param not in arguments]
+
+            if missing_params:
+                return {
+                    "valid": False,
+                    "error": f"Missing required parameters: {missing_params}",
+                    "required_parameters": required_params,
+                }
+
+            return {
+                "valid": True,
+                "message": f"Validation passed for {self.action_name}",
+            }
+
+        except Exception as e:
+            return {"valid": False, "error": f"Validation error: {str(e)}"}
+
+    def _add_metadata(self, result: Dict[str, Any]) -> Dict[str, Any]:
+        """Add standard metadata to action result"""
+        if isinstance(result, dict):
+            result["action_name"] = self.action_name
+            result["timestamp"] = datetime.now().isoformat()
+        return result
+
+    def _handle_error(self, error: Exception) -> Dict[str, Any]:
+        """Standard error handling for actions"""
+        error_result = {
+            "success": False,
+            "error": str(error),
+            "action_name": self.action_name,
+            "timestamp": datetime.now().isoformat(),
+        }
+        logger.error(f"Action {self.action_name} failed: {error}")
+        return error_result
+
+    # ================================
+    # Memory ID Utilities
+    # ================================
+
+    def _generate_memory_id(self) -> str:
+        short_uuid = str(uuid.uuid4())[:6]
+        return f"{short_uuid}"
+
+    def _add_memory_ids_to_content(self, content: str) -> str:
+        """
+        Add memory IDs to content lines
+
+        Args:
+            content: Raw content
+
+        Returns:
+            Content with memory IDs added to each line
+        """
+        if not content.strip():
+            return content
+
+        lines = content.split("\n")
+        processed_lines = []
+
+        for line in lines:
+            line = line.strip()
+            if line:  # Only process non-empty lines
+                # Always remove existing memory ID and generate a new unique one
+                if self._has_memory_id(line):
+                    # Extract content without memory ID
+                    _, clean_content = self._extract_memory_id(line)
+                    line = clean_content
+
+                # Generate new unique memory ID for this line
+                memory_id = self._generate_memory_id()
+                processed_lines.append(f"[{memory_id}] {line}")
+            else:
+                # Keep empty lines as is
+                processed_lines.append("")
+
+        return "\n".join(processed_lines)
+
+    def _has_memory_id(self, line: str) -> bool:
+        """
+        Check if a line already has a memory ID
+
+        Args:
+            line: Line to check
+
+        Returns:
+            True if line starts with [memory_id] format
+        """
+        pattern = r"^\[[\w\d_]+\]\s+"
+        return bool(re.match(pattern, line.strip()))
+
+    def _extract_memory_id(self, line: str) -> Tuple[str, str]:
+        """
+        Extract memory ID and content from a line
+
+        Args:
+            line: Line with memory ID format: [memory_id] content
+
+        Returns:
+            Tuple of (memory_id, content)
+        """
+        line = line.strip()
+        pattern = r"^\[([\w\d_]+)\]\s*(.*)"
+        match = re.match(pattern, line)
+
+        if match:
+            memory_id = match.group(1)
+            content = match.group(2)
+            return memory_id, content
+        else:
+            # If no memory ID found, return empty ID and full line as content
+            return "", line
+
+    def _extract_content_without_ids(self, content: str) -> str:
+        """
+        Extract pure content without memory IDs for embedding generation
+
+        Args:
+            content: Content with memory IDs
+
+        Returns:
+            Content without memory IDs
+        """
+        if not content.strip():
+            return content
+
+        lines = content.split("\n")
+        clean_lines = []
+
+        for line in lines:
+            if line.strip():
+                _, clean_content = self._extract_memory_id(line)
+                if clean_content:
+                    clean_lines.append(clean_content)
+            else:
+                clean_lines.append("")
+
+        return "\n".join(clean_lines)
+
+    def _parse_memory_items(self, content: str) -> list[dict[str, Any]]:
+        """
+        Parse content into memory items with IDs, supporting both old and new timestamp formats
+
+        Args:
+            content: Content with memory IDs
+
+        Returns:
+            List of memory items with metadata
+        """
+        if not content.strip():
+            return []
+
+        lines = content.split("\n")
+        items = []
+
+        for i, line in enumerate(lines):
+            line = line.strip()
+            if line:  # Only process non-empty lines
+                memory_id, mentioned_at, clean_content, links = self._extract_timestamped_memory_item(line)
+
+                if clean_content:
+                    item = {
+                        "memory_id": memory_id,
+                        "mentioned_at": mentioned_at,
+                        "content": clean_content,
+                        "links": links,
+                        "full_line": line,
+                        "line_number": i + 1,
+                    }
+                    items.append(item)
+
+        return items
+
+    def _extract_timestamped_memory_item(self, line: str) -> Tuple[str, str, str, str]:
+        """
+        Extract memory ID, content, timestamp, and links from timestamped format
+        Format: [memory_id][mentioned at date] content [links]
+
+        Args:
+            line: Line with timestamped memory format
+
+        Returns:
+            Tuple of (memory_id, content, mentioned_at, links)
+        """
+        import re
+
+        line = line.strip()
+
+        # Pattern to match: [memory_id][mentioned at date] content [links] (links optional)
+        pattern = r"^\[([^\]]+)\]\[mentioned at ([^\]]+)\]\s*(.*?)(?:\s*\[([^\]]*)\])?$"
+        match = re.match(pattern, line)
+
+        if match:
+            memory_id = match.group(1)
+            mentioned_at = match.group(2)
+            content = match.group(3).strip()
+            links = match.group(4) if match.group(4) else ""
+            return memory_id, mentioned_at, content, links
+        else:
+            return "", "", "", ""
+
+    # ================================
+    # Common utility methods that actions can use
+    # ================================
+
+    def _load_existing_memory(self, character_name: str) -> Dict[str, str]:
+        """Load existing memory content for all categories"""
+        existing_memory = {}
+
+        for category in self.storage_manager.get_flat_memory_types():
+            try:
+                content = self._read_memory_content(character_name, category)
+                existing_memory[category] = content if isinstance(content, str) else ""
+            except Exception as e:
+                logger.warning(f"Failed to load existing {category} for {character_name}: {e}")
+                existing_memory[category] = ""
+
+        return existing_memory
+
+    def _read_memory_content(self, character_name: str, category: str) -> str:
+        """Read memory content from storage"""
+        try:
+            # agent_id and user_id are managed inside storage_manager
+            return self.storage_manager.read_memory_file(category)
+        except Exception as e:
+            logger.warning(f"Failed to read {category} for {character_name}: {e}")
+            return ""
+
+    def _save_memory_content(self, character_name: str, category: str, content: str) -> bool:
+        """Save memory content to storage"""
+        try:
+            # agent_id and user_id are managed inside storage_manager
+            return self.storage_manager.write_memory_file(category, content)
+        except Exception as e:
+            logger.error(f"Failed to save {category} for {character_name}: {e}")
+            return False
+
+    def _append_memory_content(self, character_name: str, category: str, content: str) -> bool:
+        """Append memory content to storage"""
+        try:
+            # agent_id and user_id are managed inside storage_manager
+            return self.storage_manager.append_memory_file(category, content)
+        except Exception as e:
+            logger.error(f"Failed to append {category} for {character_name}: {e}")
+            return False
+
+    def _convert_conversation_to_text(self, conversation: list[dict]) -> str:
+        """Convert conversation list to text format for LLM processing"""
+        if not conversation or not isinstance(conversation, list):
+            return ""
+
+        text_parts = []
+        for message in conversation:
+            role = message.get("role", "unknown")
+            content = message.get("content", "")
+            text_parts.append(f"{role.upper()}: {content}")
+
+        return "\n".join(text_parts)