creative_agent.py

"""
Creative Agent - Handles creative content generation
"""

import os
import sys
import json
import logging
import tempfile
from typing import Dict, List, Any, Optional, Union
from pathlib import Path

from llm.llm_manager import LLMManager
from memory.memory_manager import MemoryManager

logger = logging.getLogger("vision_os.creative_agent")

class CreativeAgent:
    """
    Agent for handling creative content generation.
    Provides capabilities for generating various types of creative content,
    including text, ideas, and structured content.
    """
    
    def __init__(self, llm_manager: LLMManager, memory_manager: MemoryManager):
        """
        Initialize the creative agent
        
        Args:
            llm_manager: LLM manager instance
            memory_manager: Memory manager instance
        """
        self.llm_manager = llm_manager
        self.memory_manager = memory_manager
        
        # Content types
        self.content_types = {
            "story": "a creative narrative with characters and plot",
            "poem": "a poetic composition with rhythm and imagery",
            "essay": "a structured analytical composition on a specific topic",
            "blog_post": "an informative article for online publication",
            "social_media": "short, engaging content for social platforms",
            "business_idea": "a concept for a new business venture",
            "product_description": "compelling text describing a product's features and benefits",
            "marketing_copy": "persuasive text designed to promote a product or service",
            "email": "a professional or personal email communication",
            "presentation": "content structured for a slide presentation",
            "script": "dialogue and directions for a video or performance",
            "technical_document": "detailed technical information or instructions"
        }
        
        logger.info("Creative Agent initialized")
    
    def process(self, user_input: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """
        Process a user request related to creative content generation
        
        Args:
            user_input: The user's natural language input
            context: Optional context information
            
        Returns:
            Dictionary containing the response and any additional data
        """
        # Analyze the user input to determine the requested action
        content_type, parameters = self._determine_content_type(user_input)
        
        # Generate the requested content
        result = self.generate_content(content_type, parameters)
        
        if result["success"]:
            # For shorter content, include it directly in the response
            if len(result["content"]) < 1000:
                return {
                    "response": f"Here's the {content_type} you requested:\n\n{result['content']}",
                    "action": "generate_content",
                    "content_type": content_type,
                    "content": result["content"],
                    "success": True
                }
            else:
                # For longer content, save to a file and provide a summary
                file_path = self._save_content_to_file(content_type, result["content"])
                
                return {
                    "response": f"I've generated the {content_type} you requested and saved it to {file_path}. Here's a preview:\n\n{result['content'][:500]}...",
                    "action": "generate_content",
                    "content_type": content_type,
                    "content": result["content"],
                    "file_path": file_path,
                    "success": True
                }
        else:
            return {
                "response": f"I couldn't generate the {content_type}. {result['error']}",
                "action": "generate_content",
                "content_type": content_type,
                "success": False,
                "error": result["error"]
            }
    
    def generate_content(self, content_type: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
        """
        Generate creative content
        
        Args:
            content_type: Type of content to generate
            parameters: Parameters for content generation
            
        Returns:
            Dictionary with generated content or error message
        """
        try:
            # Check if content type is supported
            if content_type not in self.content_types and content_type != "custom":
                return {
                    "success": False,
                    "error": f"Content type '{content_type}' is not supported. Supported types: {', '.join(self.content_types.keys())}."
                }
            
            # Build the prompt based on content type and parameters
            prompt = self._build_generation_prompt(content_type, parameters)
            
            # Generate the content
            content = self.llm_manager.generate(prompt, max_tokens=2000)
            
            return {
                "success": True,
                "content": content
            }
        
        except Exception as e:
            logger.error(f"Error generating {content_type}: {str(e)}")
            return {
                "success": False,
                "error": str(e)
            }
    
    def _determine_content_type(self, user_input: str) -> tuple:
        """
        Determine the type of content to generate and extract parameters
        
        Args:
            user_input: User's natural language input
            
        Returns:
            Tuple of (content_type, parameters)
        """
        # Use LLM to extract content type and parameters
        prompt = f"""
        Analyze this request for creative content generation: "{user_input}"
        
        Determine the type of content requested and extract relevant parameters.
        
        Format your response as JSON with the following structure:
        {{
            "content_type": "one of {list(self.content_types.keys())} or 'custom'",
            "parameters": {{
                "topic": "main topic or subject",
                "style": "requested style or tone",
                "length": "requested length (short, medium, long)",
                "additional_requirements": "any other specific requirements"
            }}
        }}
        """
        
        response = self.llm_manager.generate(prompt)
        
        try:
            # Try to parse as JSON
            content_info = json.loads(response)
            content_type = content_info.get("content_type", "custom")
            parameters = content_info.get("parameters", {})
            
            # Ensure required parameters
            if "topic" not in parameters:
                parameters["topic"] = "general"
            
            if "style" not in parameters:
                parameters["style"] = "standard"
            
            if "length" not in parameters:
                parameters["length"] = "medium"
            
            return content_type, parameters
        except:
            # Fallback if JSON parsing fails
            logger.warning("Failed to parse content info as JSON. Using fallback extraction.")
            
            # Simple content type detection
            input_lower = user_input.lower()
            
            # Check for explicit content type mentions
            detected_type = "custom"
            for content_type in self.content_types:
                if content_type.replace("_", " ") in input_lower:
                    detected_type = content_type
                    break
            
            # Extract basic parameters
            parameters = {
                "topic": "general",
                "style": "standard",
                "length": "medium",
                "additional_requirements": user_input
            }
            
            return detected_type, parameters
    
    def _build_generation_prompt(self, content_type: str, parameters: Dict[str, Any]) -> str:
        """
        Build a prompt for content generation
        
        Args:
            content_type: Type of content to generate
            parameters: Parameters for content generation
            
        Returns:
            Generation prompt
        """
        # Extract parameters
        topic = parameters.get("topic", "general")
        style = parameters.get("style", "standard")
        length = parameters.get("length", "medium")
        additional_requirements = parameters.get("additional_requirements", "")
        
        # Map length to approximate word count
        length_map = {
            "short": "approximately 200-300 words",
            "medium": "approximately 500-700 words",
            "long": "approximately 1000-1500 words"
        }
        length_description = length_map.get(length.lower(), "appropriate length")
        
        # Build the prompt based on content type
        if content_type == "story":
            prompt = f"""
            Write a creative story with the following parameters:
            
            Topic/Theme: {topic}
            Style/Tone: {style}
            Length: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create a compelling narrative with well-developed characters and an engaging plot.
            """
        
        elif content_type == "poem":
            prompt = f"""
            Write a poem with the following parameters:
            
            Topic/Theme: {topic}
            Style/Tone: {style}
            Length: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create a poetic composition with rhythm, imagery, and emotional resonance.
            """
        
        elif content_type == "essay":
            prompt = f"""
            Write an essay with the following parameters:
            
            Topic: {topic}
            Style/Tone: {style}
            Length: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create a well-structured analytical composition with a clear thesis, supporting arguments, and conclusion.
            """
        
        elif content_type == "blog_post":
            prompt = f"""
            Write a blog post with the following parameters:
            
            Topic: {topic}
            Style/Tone: {style}
            Length: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create an informative and engaging article suitable for online publication, with a compelling headline, introduction, and well-organized sections.
            """
        
        elif content_type == "social_media":
            prompt = f"""
            Write social media content with the following parameters:
            
            Topic: {topic}
            Style/Tone: {style}
            Platform: {additional_requirements if additional_requirements else "general"}
            
            Create short, engaging content optimized for social media, with appropriate hashtags and calls to action.
            """
        
        elif content_type == "business_idea":
            prompt = f"""
            Generate a business idea with the following parameters:
            
            Industry/Domain: {topic}
            Innovation Style: {style}
            Detail Level: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create a comprehensive business concept including the value proposition, target market, revenue model, and potential challenges.
            """
        
        elif content_type == "product_description":
            prompt = f"""
            Write a product description with the following parameters:
            
            Product Type: {topic}
            Style/Tone: {style}
            Length: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create compelling text describing the product's features, benefits, and unique selling points.
            """
        
        elif content_type == "marketing_copy":
            prompt = f"""
            Write marketing copy with the following parameters:
            
            Product/Service: {topic}
            Style/Tone: {style}
            Length: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create persuasive text designed to promote the product or service, highlighting benefits and including effective calls to action.
            """
        
        elif content_type == "email":
            prompt = f"""
            Write an email with the following parameters:
            
            Subject/Purpose: {topic}
            Style/Tone: {style}
            Length: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create a professional email communication with appropriate greeting, body, and closing.
            """
        
        elif content_type == "presentation":
            prompt = f"""
            Create presentation content with the following parameters:
            
            Topic: {topic}
            Style/Tone: {style}
            Number of Slides: {length.lower() if length.lower() in ["short", "medium", "long"] else "10-15"}
            Additional Requirements: {additional_requirements}
            
            Structure the content for a slide presentation, including an introduction, main points, and conclusion. Format as slide titles followed by bullet points or brief paragraphs.
            """
        
        elif content_type == "script":
            prompt = f"""
            Write a script with the following parameters:
            
            Topic/Scenario: {topic}
            Style/Tone: {style}
            Length: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create dialogue and directions for a video or performance, with proper formatting for characters, dialogue, and action descriptions.
            """
        
        elif content_type == "technical_document":
            prompt = f"""
            Write a technical document with the following parameters:
            
            Subject: {topic}
            Style/Tone: {style}
            Length: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create detailed technical information or instructions, with appropriate sections, terminology, and clarity for the intended audience.
            """
        
        else:  # custom or unsupported type
            prompt = f"""
            Generate creative content based on the following parameters:
            
            Content Type: {content_type}
            Topic: {topic}
            Style/Tone: {style}
            Length: {length_description}
            Additional Requirements: {additional_requirements}
            
            Create high-quality content that meets these specifications.
            """
        
        return prompt
    
    def _save_content_to_file(self, content_type: str, content: str) -> str:
        """
        Save generated content to a file
        
        Args:
            content_type: Type of content
            content: Generated content
            
        Returns:
            Path to the saved file
        """
        try:
            # Create a file name based on content type and timestamp
            import time
            timestamp = int(time.time())
            file_name = f"{content_type}_{timestamp}.txt"
            
            # Save to Documents folder
            documents_dir = os.path.expanduser("~/Documents/VisionOS")
            os.makedirs(documents_dir, exist_ok=True)
            
            file_path = os.path.join(documents_dir, file_name)
            
            # Write the content
            with open(file_path, 'w', encoding='utf-8') as f:
                f.write(content)
            
            # Store file info in memory
            self.memory_manager.store_file_info(file_path)
            
            return file_path
        
        except Exception as e:
            logger.error(f"Error saving content to file: {str(e)}")
            
            # Fallback to temp file
            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".txt")
            temp_file.write(content.encode('utf-8'))
            temp_file.close()
            
            return temp_file.name