python -m venv venv
source venv/bin/activate
pip install openai pydantic tiktoken textstat
export OPENAI_API_KEY="sk-your-key"

import json
import logging
from typing import Any, Dict, List, Optional

from openai import AsyncOpenAI

logger = logging.getLogger(__name__)


class BrandVoiceManager:
    """Manage and enforce brand voice across content generation."""

    def __init__(self, model: str = "gpt-4o"):
        self.client = AsyncOpenAI()
        self.model = model
        self.voices: Dict[str, Dict] = {}

    def create_voice(
        self,
        name: str,
        tone: str,
        values: List[str],
        do_s: List[str],
        dont_s: List[str],
        sample_content: str = "",
    ) -> Dict[str, Any]:
        voice = {
            "name": name,
            "tone": tone,
            "values": values,
            "do_s": do_s,
            "dont_s": dont_s,
            "sample_content": sample_content,
        }
        self.voices[name] = voice
        return voice

    def get_voice_prompt(self, name: str) -> str:
        voice = self.voices.get(name, {})
        return f"""Brand Voice: {voice.get('name', 'Default')}
Tone: {voice.get('tone', 'Professional')}
Values: {', '.join(voice.get('values', []))}
Do: {'; '.join(voice.get('do_s', []))}
Don't: {'; '.join(voice.get('dont_s', []))}"""

    async def analyze_voice(self, content: str) -> Dict[str, Any]:
        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "system",
                    "content": """Analyze the brand voice of this content.
                    Return JSON: {"tone": "...", "formality": "formal|casual|mixed", "personality": "...", "target_audience": "..."}""",
                },
                {"role": "user", "content": content[:2000]},
            ],
            temperature=0.0,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except (json.JSONDecodeError, IndexError):
            return {"tone": "professional", "formality": "formal"}

class BlogGenerator:
    """Generate blog posts with storytelling frameworks and SEO optimization."""

    def __init__(self, model: str = "gpt-4o"):
        self.client = AsyncOpenAI()
        self.model = model

    async def generate(
        self,
        topic: str,
        brand_voice: str,
        word_count: int = 1500,
        keywords: Optional[List[str]] = None,
        framework: str = "AIDA",
    ) -> Dict[str, Any]:
        keyword_str = ", ".join(keywords) if keywords else "none specified"
        prompt = f"""Write a {word_count}-word blog post about: {topic}

Brand voice: {brand_voice}
Framework: {framework}
Target keywords: {keyword_str}

Structure:
1. Compelling headline
2. Hook introduction (100-150 words)
3. Main sections with H2/H3 headings
4. Conclusion with CTA

Rules:
- Use short paragraphs (2-3 sentences)
- Include transition sentences
- Add bullet points for lists
- Reference data/examples where possible
- Optimize for readability (Flesch score 60+)"""

        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "You are an expert content writer and SEO specialist."},
                {"role": "user", "content": prompt},
            ],
            temperature=0.7,
            max_tokens=4000,
        )
        content = response.choices[0].message.content
        return {"content": content, "word_count": len(content.split()), "framework": framework}


class SocialGenerator:
    """Generate social media content across platforms."""

    def __init__(self, model: str = "gpt-4o"):
        self.client = AsyncOpenAI()
        self.model = model

    async def generate_thread(self, topic: str, brand_voice: str, num_tweets: int = 5) -> List[Dict]:
        prompt = f"""Create a Twitter thread about: {topic}
Brand voice: {brand_voice}
Number of tweets: {num_tweets}

Rules:
- First tweet hooks attention
- Each tweet provides value
- Use numbers and data
- End with summary and CTA
- Under 280 chars per tweet

Return JSON array of tweets."""

        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "Create engaging Twitter threads."},
                {"role": "user", "content": prompt},
            ],
            temperature=0.8,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except (json.JSONDecodeError, IndexError):
            return [{"content": response.choices[0].message.content}]

    async def generate_linkedin(self, topic: str, brand_voice: str) -> Dict[str, Any]:
        prompt = f"""Write a LinkedIn post about: {topic}
Brand voice: {brand_voice}

Rules:
- Hook in first 2 lines
- Use line breaks for readability
- Include personal insight
- End with question for engagement
- 150-300 words"""

        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "Write engaging LinkedIn content."},
                {"role": "user", "content": prompt},
            ],
            temperature=0.7,
        )
        return {"content": response.choices[0].message.content, "platform": "linkedin"}

class SEOOptimizer:
    """Optimize content for search engines with keyword integration."""

    def __init__(self, model: str = "gpt-4o"):
        self.client = AsyncOpenAI()
        self.model = model

    async def optimize(self, content: str, target_keywords: List[str]) -> Dict[str, Any]:
        prompt = f"""Optimize this content for SEO.

Target keywords: {', '.join(target_keywords)}

Provide:
1. Optimized title (under 60 chars)
2. Meta description (under 160 chars)
3. Suggested H2/H3 headings
4. Internal linking opportunities
5. Keyword density check
6. Readability score

Return JSON with these fields."""

        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "You are an SEO expert. Optimize content for search engines."},
                {"role": "user", "content": f"Content:\n{content[:3000]}\n\n{prompt}"},
            ],
            temperature=0.3,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except (json.JSONDecodeError, IndexError):
            return {"title": "", "meta_description": "", "headings": []}


class ContentEditor:
    """Edit and refine content for clarity, flow, and readability."""

    def __init__(self, model: str = "gpt-4o"):
        self.client = AsyncOpenAI()
        self.model = model

    async def edit(self, content: str, instructions: str = "Improve clarity and flow") -> str:
        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": f"Edit this content. {instructions}. Maintain the original voice and meaning."},
                {"role": "user", "content": content},
            ],
            temperature=0.3,
        )
        return response.choices[0].message.content

    async def proofread(self, content: str) -> Dict[str, Any]:
        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "system",
                    "content": """Proofread this content.
                    Return JSON: {"corrected": "corrected text", "changes": ["list of changes"], "grammar_issues": count}""",
                },
                {"role": "user", "content": content},
            ],
            temperature=0.0,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except (json.JSONDecodeError, IndexError):
            return {"corrected": content, "changes": [], "grammar_issues": 0}

class CreativeWritingAgent:
    """Orchestrate the complete content creation pipeline."""

    def __init__(self, model: str = "gpt-4o"):
        self.brand = BrandVoiceManager(model)
        self.blog = BlogGenerator(model)
        self.social = SocialGenerator(model)
        self.seo = SEOOptimizer(model)
        self.editor = ContentEditor(model)

    async def create_blog(
        self,
        topic: str,
        brand: str = "default",
        word_count: int = 1500,
        keywords: Optional[List[str]] = None,
    ) -> Dict[str, Any]:
        voice_prompt = self.brand.get_voice_prompt(brand)
        result = await self.blog.generate(topic, voice_prompt, word_count, keywords)
        seo = await self.seo.optimize(result["content"], keywords or [])
        return {**result, "seo": seo}

    async def create_social_campaign(
        self,
        topic: str,
        brand: str,
        platforms: Optional[List[str]] = None,
    ) -> Dict[str, Any]:
        platforms = platforms or ["twitter", "linkedin"]
        voice = self.brand.get_voice_prompt(brand)
        content = {}
        if "twitter" in platforms:
            content["twitter"] = await self.social.generate_thread(topic, voice)
        if "linkedin" in platforms:
            content["linkedin"] = await self.social.generate_linkedin(topic, voice)
        return {"topic": topic, "content": content}

    async def edit_content(self, content: str, style: str = "professional") -> str:
        return await self.editor.edit(content, f"Make it {style} while maintaining quality")