@hienlh/ppm 0.9.79 → 0.9.81

package/.opencode/skills/creativity/scripts/core.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Creativity Pro Max Core - BM25 search engine for creative direction guides
+"""
+
+import csv
+import re
+from pathlib import Path
+from math import log
+from collections import defaultdict
+
+# ============ CONFIGURATION ============
+DATA_DIR = Path(__file__).parent.parent / "data"
+MAX_RESULTS = 3
+
+CSV_CONFIG = {
+    "style": {
+        "file": "styles.csv",
+        "search_cols": ["Style", "Keywords", "Purpose", "Best_For", "Color_Palette", "BG_Music"],
+        "output_cols": ["No", "Style", "Keywords", "Color_Palette", "Ideas", "Signature_Effects", "BG_Music", "VO_Style", "Purpose", "Best_For", "Avoid_For"]
+    },
+    "platform": {
+        "file": "platforms.csv",
+        "search_cols": ["Platform", "Style_Notes", "Best_Styles", "Content_Types", "Audience"],
+        "output_cols": ["Platform", "Ratio", "Length_Short", "Length_Long", "Hook_Time", "Style_Notes", "Audio", "Best_Styles", "Content_Types", "Audience", "Avoid"]
+    },
+    "voiceover": {
+        "file": "voiceover.csv",
+        "search_cols": ["Style", "Tone", "Best_For", "Direction_Keywords", "Example_Brands"],
+        "output_cols": ["Style", "Tone", "Delivery", "Pacing", "Pitch", "Energy", "Best_For", "Example_Brands", "Direction_Keywords", "Platform_Adaptation"]
+    },
+    "music": {
+        "file": "music.csv",
+        "search_cols": ["Genre", "Mood", "Best_For", "Styles_Match", "Instruments"],
+        "output_cols": ["Genre", "Mood", "BPM_Range", "Instruments", "Best_For", "Styles_Match", "Avoid_For", "Licensing_Notes"]
+    },
+    "reasoning": {
+        "file": "creative-reasoning.csv",
+        "search_cols": ["Category", "Style_Priority", "Audience_Age", "Platform_Priority"],
+        "output_cols": ["No", "Category", "Style_Priority", "Color_Mood", "Music_Mood", "VO_Style", "Key_Effects", "Platform_Priority", "Audience_Age", "Decision_Rules", "Anti_Patterns", "Severity"]
+    }
+}
+
+AVAILABLE_DOMAINS = list(CSV_CONFIG.keys())
+
+
+# ============ BM25 IMPLEMENTATION ============
+class BM25:
+    """BM25 ranking algorithm for text search"""
+
+    def __init__(self, k1=1.5, b=0.75):
+        self.k1 = k1
+        self.b = b
+        self.corpus = []
+        self.doc_lengths = []
+        self.avgdl = 0
+        self.idf = {}
+        self.doc_freqs = defaultdict(int)
+        self.N = 0
+
+    def tokenize(self, text):
+        """Lowercase, split, remove punctuation, filter short words"""
+        text = re.sub(r'[^\w\s]', ' ', str(text).lower())
+        return [w for w in text.split() if len(w) > 2]
+
+    def fit(self, documents):
+        """Build BM25 index from documents"""
+        self.corpus = [self.tokenize(doc) for doc in documents]
+        self.N = len(self.corpus)
+        if self.N == 0:
+            return
+        self.doc_lengths = [len(doc) for doc in self.corpus]
+        self.avgdl = sum(self.doc_lengths) / self.N
+
+        for doc in self.corpus:
+            seen = set()
+            for word in doc:
+                if word not in seen:
+                    self.doc_freqs[word] += 1
+                    seen.add(word)
+
+        for word, freq in self.doc_freqs.items():
+            self.idf[word] = log((self.N - freq + 0.5) / (freq + 0.5) + 1)
+
+    def score(self, query):
+        """Score all documents against query"""
+        query_tokens = self.tokenize(query)
+        scores = []
+
+        for idx, doc in enumerate(self.corpus):
+            score = 0
+            doc_len = self.doc_lengths[idx]
+            term_freqs = defaultdict(int)
+            for word in doc:
+                term_freqs[word] += 1
+
+            for token in query_tokens:
+                if token in self.idf:
+                    tf = term_freqs[token]
+                    idf = self.idf[token]
+                    numerator = tf * (self.k1 + 1)
+                    denominator = tf + self.k1 * (1 - self.b + self.b * doc_len / self.avgdl)
+                    score += idf * numerator / denominator
+
+            scores.append((idx, score))
+
+        return sorted(scores, key=lambda x: x[1], reverse=True)
+
+
+# ============ SEARCH FUNCTIONS ============
+def _load_csv(filepath):
+    """Load CSV and return list of dicts"""
+    with open(filepath, 'r', encoding='utf-8') as f:
+        return list(csv.DictReader(f))
+
+
+def _search_csv(filepath, search_cols, output_cols, query, max_results):
+    """Core search function using BM25"""
+    if not filepath.exists():
+        return []
+
+    data = _load_csv(filepath)
+
+    # Build documents from search columns
+    documents = [" ".join(str(row.get(col, "")) for col in search_cols) for row in data]
+
+    # BM25 search
+    bm25 = BM25()
+    bm25.fit(documents)
+    ranked = bm25.score(query)
+
+    # Get top results with score > 0
+    results = []
+    for idx, score in ranked[:max_results]:
+        if score > 0:
+            row = data[idx]
+            results.append({col: row.get(col, "") for col in output_cols if col in row})
+
+    return results
+
+
+def detect_domain(query):
+    """Auto-detect the most relevant domain from query"""
+    query_lower = query.lower()
+
+    domain_keywords = {
+        "style": ["style", "visual", "aesthetic", "look", "feel", "minimalist", "bold", "cinematic", "retro", "futuristic", "ugc", "authentic", "luxury", "moody"],
+        "platform": ["tiktok", "instagram", "youtube", "linkedin", "facebook", "twitter", "pinterest", "snapchat", "reels", "shorts", "stories", "platform", "channel"],
+        "voiceover": ["voiceover", "voice", "narration", "narrator", "tone", "delivery", "vo", "speaker", "announcer", "conversational", "authoritative"],
+        "music": ["music", "audio", "soundtrack", "beat", "bpm", "genre", "song", "track", "ambient", "upbeat", "orchestral", "electronic"],
+        "reasoning": ["campaign", "launch", "product", "brand", "audience", "gen z", "millennial", "b2b", "b2c", "awareness", "conversion", "lead"]
+    }
+
+    scores = {domain: sum(1 for kw in keywords if kw in query_lower) for domain, keywords in domain_keywords.items()}
+    best = max(scores, key=scores.get)
+    return best if scores[best] > 0 else "style"
+
+
+def search(query, domain=None, max_results=MAX_RESULTS):
+    """Main search function with auto-domain detection"""
+    if domain is None:
+        domain = detect_domain(query)
+
+    config = CSV_CONFIG.get(domain, CSV_CONFIG["style"])
+    filepath = DATA_DIR / config["file"]
+
+    if not filepath.exists():
+        return {"error": f"File not found: {filepath}", "domain": domain}
+
+    results = _search_csv(filepath, config["search_cols"], config["output_cols"], query, max_results)
+
+    return {
+        "domain": domain,
+        "query": query,
+        "file": config["file"],
+        "count": len(results),
+        "results": results
+    }

package/.opencode/skills/creativity/scripts/creative_brief.py

@@ -0,0 +1,470 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Creative Brief Generator - Aggregates search results and applies reasoning
+to generate comprehensive creative direction recommendations.
+
+Usage:
+    from creative_brief import generate_creative_brief
+    result = generate_creative_brief("SaaS product launch gen z", "My Campaign")
+"""
+
+import csv
+import json
+from pathlib import Path
+from core import search, DATA_DIR
+
+
+# ============ CONFIGURATION ============
+REASONING_FILE = "creative-reasoning.csv"
+
+SEARCH_CONFIG = {
+    "reasoning": {"max_results": 1},
+    "style": {"max_results": 3},
+    "platform": {"max_results": 2},
+    "voiceover": {"max_results": 2},
+    "music": {"max_results": 2}
+}
+
+
+# ============ CREATIVE BRIEF GENERATOR ============
+class CreativeBriefGenerator:
+    """Generates creative direction recommendations from aggregated searches."""
+
+    def __init__(self):
+        self.reasoning_data = self._load_reasoning()
+
+    def _load_reasoning(self) -> list:
+        """Load reasoning rules from CSV."""
+        filepath = DATA_DIR / REASONING_FILE
+        if not filepath.exists():
+            return []
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return list(csv.DictReader(f))
+
+    def _multi_domain_search(self, query: str, style_priority: list = None) -> dict:
+        """Execute searches across multiple domains."""
+        results = {}
+        for domain, config in SEARCH_CONFIG.items():
+            if domain == "style" and style_priority:
+                # For style, also search with priority keywords
+                priority_query = " ".join(style_priority[:2]) if style_priority else query
+                combined_query = f"{query} {priority_query}"
+                results[domain] = search(combined_query, domain, config["max_results"])
+            else:
+                results[domain] = search(query, domain, config["max_results"])
+        return results
+
+    def _find_reasoning_rule(self, category: str) -> dict:
+        """Find matching reasoning rule for a category."""
+        category_lower = category.lower()
+
+        # Try exact match first
+        for rule in self.reasoning_data:
+            if rule.get("Category", "").lower() == category_lower:
+                return rule
+
+        # Try partial match
+        for rule in self.reasoning_data:
+            cat = rule.get("Category", "").lower()
+            if cat in category_lower or category_lower in cat:
+                return rule
+
+        # Try keyword match
+        for rule in self.reasoning_data:
+            cat = rule.get("Category", "").lower()
+            keywords = cat.replace("/", " ").replace("-", " ").split()
+            if any(kw in category_lower for kw in keywords):
+                return rule
+
+        return {}
+
+    def _apply_reasoning(self, category: str, search_results: dict) -> dict:
+        """Apply reasoning rules to search results."""
+        rule = self._find_reasoning_rule(category)
+
+        if not rule:
+            return {
+                "style_priority": ["Minimalist Clean", "Gradient Smooth"],
+                "color_mood": "Professional",
+                "music_mood": "Ambient electronic",
+                "vo_style": "Conversational Friendly",
+                "key_effects": "Clean transitions",
+                "platform_priority": "Instagram, YouTube",
+                "anti_patterns": "",
+                "decision_rules": {},
+                "severity": "MEDIUM"
+            }
+
+        # Parse decision rules JSON
+        decision_rules = {}
+        try:
+            decision_rules = json.loads(rule.get("Decision_Rules", "{}"))
+        except json.JSONDecodeError:
+            pass
+
+        return {
+            "style_priority": [s.strip() for s in rule.get("Style_Priority", "").split("+")],
+            "color_mood": rule.get("Color_Mood", ""),
+            "music_mood": rule.get("Music_Mood", ""),
+            "vo_style": rule.get("VO_Style", ""),
+            "key_effects": rule.get("Key_Effects", ""),
+            "platform_priority": rule.get("Platform_Priority", ""),
+            "audience_age": rule.get("Audience_Age", ""),
+            "anti_patterns": rule.get("Anti_Patterns", ""),
+            "decision_rules": decision_rules,
+            "severity": rule.get("Severity", "MEDIUM")
+        }
+
+    def _select_best_match(self, results: list, priority_keywords: list) -> dict:
+        """Select best matching result based on priority keywords."""
+        if not results:
+            return {}
+
+        if not priority_keywords:
+            return results[0]
+
+        # First: try exact style name match
+        for priority in priority_keywords:
+            priority_lower = priority.lower().strip()
+            for result in results:
+                style_name = result.get("Style", "").lower()
+                if priority_lower in style_name or style_name in priority_lower:
+                    return result
+
+        # Second: score by keyword match in all fields
+        scored = []
+        for result in results:
+            result_str = str(result).lower()
+            score = 0
+            for kw in priority_keywords:
+                kw_lower = kw.lower().strip()
+                # Higher score for style name match
+                if kw_lower in result.get("Style", "").lower():
+                    score += 10
+                # Lower score for keyword field match
+                elif kw_lower in result.get("Keywords", "").lower():
+                    score += 3
+                # Even lower for other field matches
+                elif kw_lower in result_str:
+                    score += 1
+            scored.append((score, result))
+
+        scored.sort(key=lambda x: x[0], reverse=True)
+        return scored[0][1] if scored and scored[0][0] > 0 else results[0]
+
+    def _extract_results(self, search_result: dict) -> list:
+        """Extract results list from search result dict."""
+        return search_result.get("results", [])
+
+    def generate(self, query: str, campaign_name: str = None) -> dict:
+        """Generate complete creative brief recommendation."""
+        # Step 1: First search reasoning to get category
+        reasoning_result = search(query, "reasoning", 1)
+        reasoning_results = reasoning_result.get("results", [])
+        category = "General Campaign"
+        if reasoning_results:
+            category = reasoning_results[0].get("Category", "General Campaign")
+
+        # Step 2: Get reasoning rules for this category
+        reasoning = self._apply_reasoning(category, {})
+        style_priority = reasoning.get("style_priority", [])
+
+        # Step 3: Multi-domain search with style priority hints
+        search_results = self._multi_domain_search(query, style_priority)
+        search_results["reasoning"] = reasoning_result  # Reuse reasoning search
+
+        # Step 4: Select best matches from each domain using priority
+        style_results = self._extract_results(search_results.get("style", {}))
+        platform_results = self._extract_results(search_results.get("platform", {}))
+        voiceover_results = self._extract_results(search_results.get("voiceover", {}))
+        music_results = self._extract_results(search_results.get("music", {}))
+
+        best_style = self._select_best_match(style_results, reasoning.get("style_priority", []))
+        best_platform = platform_results[0] if platform_results else {}
+        best_voiceover = voiceover_results[0] if voiceover_results else {}
+        best_music = music_results[0] if music_results else {}
+
+        # Step 5: Build final recommendation
+        return {
+            "campaign_name": campaign_name or query.upper(),
+            "category": category,
+            "style": {
+                "name": best_style.get("Style", "Minimalist Clean"),
+                "keywords": best_style.get("Keywords", ""),
+                "color_palette": best_style.get("Color_Palette", ""),
+                "signature_effects": best_style.get("Signature_Effects", ""),
+                "ideas": best_style.get("Ideas", ""),
+                "best_for": best_style.get("Best_For", ""),
+                "avoid_for": best_style.get("Avoid_For", "")
+            },
+            "platform": {
+                "name": best_platform.get("Platform", "Instagram"),
+                "ratio": best_platform.get("Ratio", "9:16"),
+                "length": f"{best_platform.get('Length_Short', '15s')} - {best_platform.get('Length_Long', '60s')}",
+                "hook_time": best_platform.get("Hook_Time", "3s"),
+                "style_notes": best_platform.get("Style_Notes", ""),
+                "content_types": best_platform.get("Content_Types", ""),
+                "avoid": best_platform.get("Avoid", "")
+            },
+            "voiceover": {
+                "style": best_voiceover.get("Style", reasoning.get("vo_style", "Conversational Friendly")),
+                "tone": best_voiceover.get("Tone", ""),
+                "delivery": best_voiceover.get("Delivery", ""),
+                "pacing": best_voiceover.get("Pacing", ""),
+                "energy": best_voiceover.get("Energy", ""),
+                "direction_keywords": best_voiceover.get("Direction_Keywords", "")
+            },
+            "music": {
+                "genre": best_music.get("Genre", "Ambient Electronic"),
+                "mood": best_music.get("Mood", reasoning.get("music_mood", "")),
+                "bpm_range": best_music.get("BPM_Range", ""),
+                "instruments": best_music.get("Instruments", ""),
+                "licensing_notes": best_music.get("Licensing_Notes", "")
+            },
+            "key_effects": reasoning.get("key_effects", best_style.get("Signature_Effects", "")),
+            "anti_patterns": reasoning.get("anti_patterns", ""),
+            "audience_age": reasoning.get("audience_age", ""),
+            "decision_rules": reasoning.get("decision_rules", {}),
+            "severity": reasoning.get("severity", "MEDIUM")
+        }
+
+
+# ============ OUTPUT FORMATTERS ============
+BOX_WIDTH = 90
+
+def format_ascii_box(brief: dict) -> str:
+    """Format creative brief as ASCII box."""
+    campaign = brief.get("campaign_name", "CAMPAIGN")
+    category = brief.get("category", "")
+    style = brief.get("style", {})
+    platform = brief.get("platform", {})
+    voiceover = brief.get("voiceover", {})
+    music = brief.get("music", {})
+    effects = brief.get("key_effects", "")
+    anti_patterns = brief.get("anti_patterns", "")
+    audience_age = brief.get("audience_age", "")
+
+    def wrap_text(text: str, prefix: str, width: int) -> list:
+        """Wrap long text into multiple lines."""
+        if not text:
+            return []
+        words = text.split()
+        lines = []
+        current_line = prefix
+        for word in words:
+            if len(current_line) + len(word) + 1 <= width - 2:
+                current_line += (" " if current_line != prefix else "") + word
+            else:
+                if current_line != prefix:
+                    lines.append(current_line)
+                current_line = prefix + word
+        if current_line != prefix:
+            lines.append(current_line)
+        return lines
+
+    # Build output lines
+    lines = []
+    w = BOX_WIDTH - 1
+
+    lines.append("+" + "-" * w + "+")
+    lines.append(f"|  CREATIVE BRIEF: {campaign}".ljust(BOX_WIDTH) + "|")
+    lines.append(f"|  Category: {category} | Audience: {audience_age}".ljust(BOX_WIDTH) + "|")
+    lines.append("+" + "-" * w + "+")
+    lines.append("|" + " " * BOX_WIDTH + "|")
+
+    # Style section
+    lines.append(f"|  VISUAL STYLE: {style.get('name', '')}".ljust(BOX_WIDTH) + "|")
+    if style.get("keywords"):
+        for line in wrap_text(f"Keywords: {style.get('keywords', '')}", "|     ", BOX_WIDTH):
+            lines.append(line.ljust(BOX_WIDTH) + "|")
+    if style.get("color_palette"):
+        lines.append(f"|     Colors: {style.get('color_palette', '')}".ljust(BOX_WIDTH) + "|")
+    if style.get("signature_effects"):
+        for line in wrap_text(f"Effects: {style.get('signature_effects', '')}", "|     ", BOX_WIDTH):
+            lines.append(line.ljust(BOX_WIDTH) + "|")
+    if style.get("ideas"):
+        for line in wrap_text(f"Ideas: {style.get('ideas', '')}", "|     ", BOX_WIDTH):
+            lines.append(line.ljust(BOX_WIDTH) + "|")
+    lines.append("|" + " " * BOX_WIDTH + "|")
+
+    # Platform section
+    lines.append(f"|  PLATFORM: {platform.get('name', '')}".ljust(BOX_WIDTH) + "|")
+    lines.append(f"|     Ratio: {platform.get('ratio', '')} | Length: {platform.get('length', '')} | Hook: {platform.get('hook_time', '')}".ljust(BOX_WIDTH) + "|")
+    if platform.get("style_notes"):
+        for line in wrap_text(f"Notes: {platform.get('style_notes', '')}", "|     ", BOX_WIDTH):
+            lines.append(line.ljust(BOX_WIDTH) + "|")
+    if platform.get("content_types"):
+        for line in wrap_text(f"Content: {platform.get('content_types', '')}", "|     ", BOX_WIDTH):
+            lines.append(line.ljust(BOX_WIDTH) + "|")
+    lines.append("|" + " " * BOX_WIDTH + "|")
+
+    # Voiceover section
+    lines.append(f"|  VOICEOVER: {voiceover.get('style', '')}".ljust(BOX_WIDTH) + "|")
+    lines.append(f"|     Tone: {voiceover.get('tone', '')}".ljust(BOX_WIDTH) + "|")
+    lines.append(f"|     Delivery: {voiceover.get('delivery', '')}".ljust(BOX_WIDTH) + "|")
+    lines.append(f"|     Pacing: {voiceover.get('pacing', '')} | Energy: {voiceover.get('energy', '')}".ljust(BOX_WIDTH) + "|")
+    if voiceover.get("direction_keywords"):
+        for line in wrap_text(f"Direction: {voiceover.get('direction_keywords', '')}", "|     ", BOX_WIDTH):
+            lines.append(line.ljust(BOX_WIDTH) + "|")
+    lines.append("|" + " " * BOX_WIDTH + "|")
+
+    # Music section
+    lines.append(f"|  MUSIC: {music.get('genre', '')}".ljust(BOX_WIDTH) + "|")
+    lines.append(f"|     Mood: {music.get('mood', '')} | BPM: {music.get('bpm_range', '')}".ljust(BOX_WIDTH) + "|")
+    if music.get("instruments"):
+        for line in wrap_text(f"Instruments: {music.get('instruments', '')}", "|     ", BOX_WIDTH):
+            lines.append(line.ljust(BOX_WIDTH) + "|")
+    if music.get("licensing_notes"):
+        lines.append(f"|     Licensing: {music.get('licensing_notes', '')}".ljust(BOX_WIDTH) + "|")
+    lines.append("|" + " " * BOX_WIDTH + "|")
+
+    # Anti-patterns section
+    if anti_patterns:
+        lines.append("|  AVOID (Anti-patterns):".ljust(BOX_WIDTH) + "|")
+        for line in wrap_text(anti_patterns, "|     ", BOX_WIDTH):
+            lines.append(line.ljust(BOX_WIDTH) + "|")
+        lines.append("|" + " " * BOX_WIDTH + "|")
+
+    # Checklist section
+    lines.append("|  PRE-PRODUCTION CHECKLIST:".ljust(BOX_WIDTH) + "|")
+    checklist_items = [
+        "[ ] Brand guidelines reviewed",
+        "[ ] Audience persona confirmed",
+        "[ ] Creative style approved",
+        "[ ] Platform specs verified",
+        "[ ] Success metrics defined",
+        "[ ] Hook in first 3 seconds",
+        "[ ] Sound-off optimized (captions)",
+        "[ ] Mobile-first designed"
+    ]
+    for item in checklist_items:
+        lines.append(f"|     {item}".ljust(BOX_WIDTH) + "|")
+    lines.append("|" + " " * BOX_WIDTH + "|")
+
+    lines.append("+" + "-" * w + "+")
+
+    return "\n".join(lines)
+
+
+def format_markdown(brief: dict) -> str:
+    """Format creative brief as markdown."""
+    campaign = brief.get("campaign_name", "CAMPAIGN")
+    category = brief.get("category", "")
+    style = brief.get("style", {})
+    platform = brief.get("platform", {})
+    voiceover = brief.get("voiceover", {})
+    music = brief.get("music", {})
+    effects = brief.get("key_effects", "")
+    anti_patterns = brief.get("anti_patterns", "")
+    audience_age = brief.get("audience_age", "")
+
+    lines = []
+    lines.append(f"## Creative Brief: {campaign}")
+    lines.append(f"**Category:** {category} | **Audience:** {audience_age}")
+    lines.append("")
+
+    # Style section
+    lines.append("### Visual Style")
+    lines.append(f"- **Name:** {style.get('name', '')}")
+    if style.get('keywords'):
+        lines.append(f"- **Keywords:** {style.get('keywords', '')}")
+    if style.get('color_palette'):
+        lines.append(f"- **Colors:** {style.get('color_palette', '')}")
+    if style.get('signature_effects'):
+        lines.append(f"- **Effects:** {style.get('signature_effects', '')}")
+    if style.get('ideas'):
+        lines.append(f"- **Ideas:** {style.get('ideas', '')}")
+    if style.get('best_for'):
+        lines.append(f"- **Best For:** {style.get('best_for', '')}")
+    if style.get('avoid_for'):
+        lines.append(f"- **Avoid For:** {style.get('avoid_for', '')}")
+    lines.append("")
+
+    # Platform section
+    lines.append("### Platform")
+    lines.append(f"- **Platform:** {platform.get('name', '')}")
+    lines.append(f"- **Ratio:** {platform.get('ratio', '')} | **Length:** {platform.get('length', '')} | **Hook:** {platform.get('hook_time', '')}")
+    if platform.get('style_notes'):
+        lines.append(f"- **Notes:** {platform.get('style_notes', '')}")
+    if platform.get('content_types'):
+        lines.append(f"- **Content Types:** {platform.get('content_types', '')}")
+    if platform.get('avoid'):
+        lines.append(f"- **Avoid:** {platform.get('avoid', '')}")
+    lines.append("")
+
+    # Voiceover section
+    lines.append("### Voiceover")
+    lines.append(f"- **Style:** {voiceover.get('style', '')}")
+    lines.append(f"- **Tone:** {voiceover.get('tone', '')}")
+    lines.append(f"- **Delivery:** {voiceover.get('delivery', '')}")
+    lines.append(f"- **Pacing:** {voiceover.get('pacing', '')} | **Energy:** {voiceover.get('energy', '')}")
+    if voiceover.get('direction_keywords'):
+        lines.append(f"- **Direction:** {voiceover.get('direction_keywords', '')}")
+    lines.append("")
+
+    # Music section
+    lines.append("### Music/Audio")
+    lines.append(f"- **Genre:** {music.get('genre', '')}")
+    lines.append(f"- **Mood:** {music.get('mood', '')} | **BPM:** {music.get('bpm_range', '')}")
+    if music.get('instruments'):
+        lines.append(f"- **Instruments:** {music.get('instruments', '')}")
+    if music.get('licensing_notes'):
+        lines.append(f"- **Licensing:** {music.get('licensing_notes', '')}")
+    lines.append("")
+
+    # Anti-patterns section
+    if anti_patterns:
+        lines.append("### Avoid (Anti-patterns)")
+        lines.append(f"- {anti_patterns.replace(', ', '\n- ')}")
+        lines.append("")
+
+    # Checklist
+    lines.append("### Pre-Production Checklist")
+    lines.append("- [ ] Brand guidelines reviewed")
+    lines.append("- [ ] Audience persona confirmed")
+    lines.append("- [ ] Creative style approved")
+    lines.append("- [ ] Platform specs verified")
+    lines.append("- [ ] Success metrics defined")
+    lines.append("- [ ] Hook in first 3 seconds")
+    lines.append("- [ ] Sound-off optimized (captions)")
+    lines.append("- [ ] Mobile-first designed")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+# ============ MAIN ENTRY POINT ============
+def generate_creative_brief(query: str, campaign_name: str = None, output_format: str = "ascii") -> str:
+    """
+    Main entry point for creative brief generation.
+
+    Args:
+        query: Search query (e.g., "SaaS product launch gen z")
+        campaign_name: Optional campaign name for output header
+        output_format: "ascii" (default) or "markdown"
+
+    Returns:
+        Formatted creative brief string
+    """
+    generator = CreativeBriefGenerator()
+    brief = generator.generate(query, campaign_name)
+
+    if output_format == "markdown":
+        return format_markdown(brief)
+    return format_ascii_box(brief)
+
+
+# ============ CLI SUPPORT ============
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate Creative Brief")
+    parser.add_argument("query", help="Search query (e.g., 'SaaS product launch')")
+    parser.add_argument("--campaign-name", "-c", type=str, default=None, help="Campaign name")
+    parser.add_argument("--format", "-f", choices=["ascii", "markdown"], default="ascii", help="Output format")
+
+    args = parser.parse_args()
+
+    result = generate_creative_brief(args.query, args.campaign_name, args.format)
+    print(result)