python -m venv venv
source venv/bin/activate
pip install openai tweepy schedule pandas
export OPENAI_API_KEY="sk-your-key"

# content/generator.py
from openai import OpenAI
from typing import Dict, List

class ContentGenerator:
    def __init__(self, model: str = "gpt-4-turbo-preview"):
        self.client = OpenAI()
        self.model = model

    def generate_post(
        self,
        topic: str,
        platform: str,
        brand_voice: str,
        tone: str = "professional",
        include_hashtags: bool = True,
    ) -> Dict:
        char_limits = {"twitter": 280, "linkedin": 3000, "instagram": 2200}
        limit = char_limits.get(platform, 280)
        prompt = f"""Create a {platform} post about: {topic}

Brand voice: {brand_voice}
Tone: {tone}
Character limit: {limit}
Include hashtags: {include_hashtags}

Platform-specific rules:
- Twitter: Concise, punchy, use threads for longer content
- LinkedIn: Professional, thought leadership, include CTA
- Instagram: Visual-focused, emoji-friendly, strong hashtag game

Return JSON:
{{
    "content": "the post text",
    "hashtags": ["list of hashtags"],
    "best_posting_time": "suggested time",
    "engagement_prediction": "high|medium|low"
}}"""
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "You are an expert social media copywriter."},
                {"role": "user", "content": prompt},
            ],
            temperature=0.7,
        )
        import json
        try:
            return json.loads(response.choices[0].message.content)
        except:
            return {"content": response.choices[0].message.content, "hashtags": [], "best_posting_time": "09:00"}

    def generate_content_calendar(
        self,
        topics: List[str],
        brand_voice: str,
        days: int = 7,
    ) -> List[Dict]:
        calendar = []
        platforms = ["twitter", "linkedin", "instagram"]
        for day in range(days):
            for i, topic in enumerate(topics[:len(platforms)]):
                platform = platforms[i % len(platforms)]
                post = self.generate_post(topic, platform, brand_voice)
                calendar.append({
                    "day": day + 1,
                    "platform": platform,
                    "topic": topic,
                    **post,
                })
        return calendar

# content/brand_voice.py
from typing import Dict

class BrandVoiceManager:
    def __init__(self):
        self.voices: Dict[str, str] = {}

    def add_voice(self, brand_name: str, description: str) -> None:
        self.voices[brand_name] = description

    def get_voice(self, brand_name: str) -> str:
        return self.voices.get(brand_name, "Professional and helpful")

    def create_voice_profile(
        self,
        brand_name: str,
        values: List[str],
        tone: str,
        do_s: List[str],
        dont_s: List[str],
    ) -> str:
        profile = f"""Brand: {brand_name}
Tone: {tone}
Values: {', '.join(values)}
Do: {'; '.join(do_s)}
Don't: {'; '.join(dont_s)}"""
        self.voices[brand_name] = profile
        return profile

# platforms/twitter.py
from typing import Dict

class TwitterClient:
    def __init__(self, api_key: str, api_secret: str, access_token: str, access_secret: str):
        import tweepy
        auth = tweepy.OAuth1UserHandler(api_key, api_secret, access_token, access_secret)
        self.client = tweepy.Client(
            consumer_key=api_key,
            consumer_secret=api_secret,
            access_token=access_token,
            access_token_secret=access_secret,
        )

    def post_tweet(self, content: str, hashtags: list = None) -> Dict:
        text = content
        if hashtags:
            tag_str = " ".join(f"#{t.strip('#')}" for t in hashtags[:5])
            if len(text) + len(tag_str) + 1 <= 280:
                text = f"{text}\n\n{tag_str}"
        try:
            response = self.client.create_tweet(text=text)
            return {"success": True, "tweet_id": response.data["id"]}
        except Exception as e:
            return {"success": False, "error": str(e)}

    def get_mentions(self, count: int = 10) -> list:
        try:
            response = self.client.get_users_mentions(
                self.client.get_me().data.id,
                max_results=count,
                tweet_fields=["text", "created_at"],
            )
            return [{"id": m.id, "text": m.text, "created_at": m.created_at} for m in (response.data or [])]
        except:
            return []

# scheduling/scheduler.py
import schedule
import time
from typing import Dict, Callable
from datetime import datetime

class PostScheduler:
    def __init__(self):
        self.scheduled_posts: list = []

    def schedule_post(self, post: Dict, post_time: str, callback: Callable) -> None:
        self.scheduled_posts.append({
            "post": post,
            "time": post_time,
            "callback": callback,
            "status": "scheduled",
        })
        schedule.every().day.at(post_time).do(self._execute_post, post, callback)

    def _execute_post(self, post: Dict, callback: Callable) -> None:
        result = callback(post.get("content", ""), post.get("hashtags", []))
        post["status"] = "posted" if result.get("success") else "failed"
        post["result"] = result

    def get_optimal_times(self) -> list:
        return ["09:00", "12:00", "17:00", "20:00"]

    def run_pending(self) -> None:
        schedule.run_pending()

    def get_scheduled(self) -> list:
        return self.scheduled_posts

# analytics/tracker.py
from typing import Dict, List
import pandas as pd
from datetime import datetime

class AnalyticsTracker:
    def __init__(self):
        self.posts: List[Dict] = []

    def record_post(self, post: Dict, platform: str) -> None:
        post["platform"] = platform
        post["posted_at"] = datetime.now().isoformat()
        post["metrics"] = {"likes": 0, "shares": 0, "comments": 0, "impressions": 0}
        self.posts.append(post)

    def update_metrics(self, post_id: str, metrics: Dict) -> None:
        for post in self.posts:
            if post.get("id") == post_id:
                post["metrics"].update(metrics)
                break

    def get_performance(self, platform: str = None) -> Dict:
        posts = [p for p in self.posts if not platform or p.get("platform") == platform]
        if not posts:
            return {"total_posts": 0}
        total_metrics = {"likes": 0, "shares": 0, "comments": 0, "impressions": 0}
        for post in posts:
            for key in total_metrics:
                total_metrics[key] += post.get("metrics", {}).get(key, 0)
        avg_metrics = {k: v / len(posts) for k, v in total_metrics.items()}
        return {
            "total_posts": len(posts),
            "total_metrics": total_metrics,
            "avg_metrics": avg_metrics,
            "engagement_rate": (total_metrics["likes"] + total_metrics["shares"] + total_metrics["comments"]) / max(total_metrics["impressions"], 1) * 100,
        }

    def get_content_insights(self) -> Dict:
        if not self.posts:
            return {}
        df = pd.DataFrame(self.posts)
        return {
            "best_performing": max(self.posts, key=lambda p: sum(p.get("metrics", {}).values())),
            "platforms": df["platform"].value_counts().to_dict() if "platform" in df.columns else {},
        }

# agent.py
from content.generator import ContentGenerator
from content.brand_voice import BrandVoiceManager
from analytics.tracker import AnalyticsTracker
from scheduling.scheduler import PostScheduler
from typing import Dict, List

class SocialMediaAgent:
    def __init__(self, model: str = "gpt-4-turbo-preview"):
        self.generator = ContentGenerator(model)
        self.brand_voice = BrandVoiceManager()
        self.analytics = AnalyticsTracker()
        self.scheduler = PostScheduler()

    def create_post(
        self,
        topic: str,
        platform: str,
        brand: str = "default",
        tone: str = "professional",
    ) -> Dict:
        voice = self.brand_voice.get_voice(brand)
        return self.generator.generate_post(topic, platform, voice, tone)

    def schedule_post(self, post: Dict, platform: str, time: str) -> None:
        self.scheduler.schedule_post(post, time, lambda c, h: {"success": True})
        self.analytics.record_post(post, platform)

    def generate_calendar(
        self,
        topics: List[str],
        brand: str = "default",
        days: int = 7,
    ) -> List[Dict]:
        voice = self.brand_voice.get_voice(brand)
        return self.generator.generate_content_calendar(topics, voice, days)

    def get_analytics(self, platform: str = None) -> Dict:
        return self.analytics.get_performance(platform)

import pytest
from agent import SocialMediaAgent

def test_create_post():
    agent = SocialMediaAgent()
    post = agent.create_post("AI agents", "twitter", tone="casual")
    assert "content" in post
    assert len(post["content"]) <= 280

def test_brand_voice():
    manager = BrandVoiceManager()
    manager.add_voice("tech", "Technical and innovative")
    assert manager.get_voice("tech") == "Technical and innovative"

# main.py
from agent import SocialMediaAgent

def main():
    agent = SocialMediaAgent()
    agent.brand_voice.add_voice("tech_startup", "Innovative, technical, forward-thinking")
    print("Social Media Agent Ready\n")
    while True:
        cmd = input("Command (create/calendar/analytics/quit): ").strip()
        if cmd == "quit":
            break
        elif cmd == "create":
            topic = input("Topic: ").strip()
            platform = input("Platform (twitter/linkedin): ").strip()
            post = agent.create_post(topic, platform)
            print(f"\n{post['content']}\n")

if __name__ == "__main__":
    main()