init

.opencode/skills/design/scripts/logo/core.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Logo Design Core - BM25 search engine for logo design guidelines
+"""
+
+import csv
+import re
+from pathlib import Path
+from math import log
+from collections import defaultdict
+
+# ============ CONFIGURATION ============
+DATA_DIR = Path(__file__).parent.parent.parent / "data" / "logo"
+MAX_RESULTS = 3
+
+CSV_CONFIG = {
+    "style": {
+        "file": "styles.csv",
+        "search_cols": ["Style Name", "Category", "Keywords", "Best For"],
+        "output_cols": ["Style Name", "Category", "Keywords", "Primary Colors", "Secondary Colors", "Typography", "Effects", "Best For", "Avoid For", "Complexity", "Era"]
+    },
+    "color": {
+        "file": "colors.csv",
+        "search_cols": ["Palette Name", "Category", "Keywords", "Psychology", "Best For"],
+        "output_cols": ["Palette Name", "Category", "Keywords", "Primary Hex", "Secondary Hex", "Accent Hex", "Background Hex", "Text Hex", "Psychology", "Best For", "Avoid For"]
+    },
+    "industry": {
+        "file": "industries.csv",
+        "search_cols": ["Industry", "Keywords", "Recommended Styles", "Mood"],
+        "output_cols": ["Industry", "Keywords", "Recommended Styles", "Primary Colors", "Typography", "Common Symbols", "Mood", "Best Practices", "Avoid"]
+    }
+}
+
+
+# ============ 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", "minimalist", "vintage", "modern", "retro", "geometric", "abstract", "emblem", "badge", "wordmark", "mascot", "luxury", "playful", "corporate"],
+        "color": ["color", "palette", "hex", "#", "rgb", "blue", "red", "green", "gold", "warm", "cool", "vibrant", "pastel"],
+        "industry": ["tech", "healthcare", "finance", "legal", "restaurant", "food", "fashion", "beauty", "education", "sports", "fitness", "real estate", "crypto", "gaming"]
+    }
+
+    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
+    }
+
+
+def search_all(query, max_results=2):
+    """Search across all domains and combine results"""
+    all_results = {}
+    for domain in CSV_CONFIG.keys():
+        result = search(query, domain, max_results)
+        if result.get("results"):
+            all_results[domain] = result["results"]
+    return all_results

.opencode/skills/design/scripts/logo/generate.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Logo Generation Script using Gemini Nano Banana API
+Uses Gemini 3.1 Flash Image Preview and Gemini 3 Pro Image Preview models
+
+Models:
+- Nano Banana 2 (default): gemini-3.1-flash-image-preview - fastest, 95% Pro quality, web grounding
+- Nano Banana Pro (--pro): gemini-3-pro-image-preview - professional quality, advanced reasoning
+
+Usage:
+    python generate.py --prompt "tech startup logo minimalist blue"
+    python generate.py --prompt "coffee shop vintage badge" --style vintage --output logo.png
+    python generate.py --brand "TechFlow" --industry tech --style minimalist
+    python generate.py --brand "TechFlow" --pro  # Use Nano Banana Pro model
+
+Batch mode (generates multiple variants):
+    python generate.py --brand "Unikorn" --batch 9 --output-dir ./logos --pro
+"""
+
+import argparse
+import os
+import sys
+import time
+from pathlib import Path
+from datetime import datetime
+
+# Load environment variables
+def load_env():
+    """Load .env files in priority order"""
+    env_paths = [
+        Path(__file__).parent.parent.parent / ".env",
+        Path.home() / ".claude" / "skills" / ".env",
+        Path.home() / ".claude" / ".env"
+    ]
+
+    for env_path in env_paths:
+        if env_path.exists():
+            with open(env_path) as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#') and '=' in line:
+                        key, value = line.split('=', 1)
+                        if key not in os.environ:
+                            os.environ[key] = value.strip('"\'')
+
+load_env()
+
+try:
+    from google import genai
+    from google.genai import types
+except ImportError:
+    print("Error: google-genai package not installed.")
+    print("Install with: pip install google-genai")
+    sys.exit(1)
+
+
+# ============ CONFIGURATION ============
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+
+# Gemini "Nano Banana" model configurations for image generation
+GEMINI_FLASH = "gemini-3.1-flash-image-preview"  # Nano Banana 2: fastest, 95% Pro quality, web grounding
+GEMINI_PRO = "gemini-3-pro-image-preview"  # Nano Banana Pro: professional quality, advanced reasoning
+
+# Supported aspect ratios
+ASPECT_RATIOS = ["1:1", "16:9", "9:16", "4:3", "3:4"]
+DEFAULT_ASPECT_RATIO = "1:1"  # Square is ideal for logos
+
+# Logo-specific prompt templates
+LOGO_PROMPT_TEMPLATE = """Generate a professional logo image: {prompt}
+
+Style requirements:
+- Clean vector-style illustration suitable for a logo
+- Simple, scalable design that works at any size
+- Clear silhouette and recognizable shape
+- Professional quality suitable for business use
+- Centered composition on plain white or transparent background
+- No text unless specifically requested
+- High contrast and clear edges
+- Square format, perfectly centered
+- Output as a clean, high-quality logo image
+"""
+
+STYLE_MODIFIERS = {
+    "minimalist": "minimalist, simple geometric shapes, clean lines, lots of white space, single color or limited palette",
+    "vintage": "vintage, retro, badge style, distressed texture, heritage feel, warm earth tones",
+    "modern": "modern, sleek, gradient colors, tech-forward, innovative feel",
+    "luxury": "luxury, elegant, gold accents, refined, premium feel, serif typography",
+    "playful": "playful, fun, colorful, friendly, approachable, rounded shapes",
+    "corporate": "corporate, professional, trustworthy, stable, conservative colors",
+    "organic": "organic, natural, flowing lines, earth tones, sustainable feel",
+    "geometric": "geometric, abstract, mathematical precision, symmetrical",
+    "hand-drawn": "hand-drawn, artisan, sketch-like, authentic, imperfect lines",
+    "3d": "3D, dimensional, depth, shadows, isometric perspective",
+    "abstract": "abstract mark, conceptual, symbolic, non-literal representation, artistic interpretation",
+    "lettermark": "lettermark, single letter or initials, typographic, monogram style, distinctive character",
+    "wordmark": "wordmark, logotype, custom typography, brand name as logo, distinctive lettering",
+    "emblem": "emblem, badge, crest style, enclosed design, traditional, authoritative feel",
+    "mascot": "mascot, character, friendly face, personified, memorable figure",
+    "gradient": "gradient, color transition, vibrant, modern digital feel, smooth color flow",
+    "lineart": "line art, single stroke, continuous line, elegant simplicity, wire-frame style",
+    "negative-space": "negative space, clever use of white space, hidden meaning, dual imagery, optical illusion"
+}
+
+INDUSTRY_PROMPTS = {
+    "tech": "technology company, digital, innovative, modern, circuit-like elements",
+    "healthcare": "healthcare, medical, caring, trust, cross or heart symbol",
+    "finance": "financial services, stable, trustworthy, growth, upward elements",
+    "food": "food and beverage, appetizing, warm colors, welcoming",
+    "fashion": "fashion brand, elegant, stylish, refined, artistic",
+    "fitness": "fitness and sports, dynamic, energetic, powerful, movement",
+    "eco": "eco-friendly, sustainable, natural, green, leaf or earth elements",
+    "education": "education, knowledge, growth, learning, book or cap symbol",
+    "real-estate": "real estate, property, home, roof or building silhouette",
+    "creative": "creative agency, artistic, unique, expressive, colorful"
+}
+
+
+def enhance_prompt(base_prompt, style=None, industry=None, brand_name=None):
+    """Enhance the logo prompt with style and industry modifiers"""
+    prompt_parts = [base_prompt]
+
+    if style and style in STYLE_MODIFIERS:
+        prompt_parts.append(STYLE_MODIFIERS[style])
+
+    if industry and industry in INDUSTRY_PROMPTS:
+        prompt_parts.append(INDUSTRY_PROMPTS[industry])
+
+    if brand_name:
+        prompt_parts.insert(0, f"Logo for '{brand_name}':")
+
+    combined = ", ".join(prompt_parts)
+    return LOGO_PROMPT_TEMPLATE.format(prompt=combined)
+
+
+def generate_logo(prompt, style=None, industry=None, brand_name=None,
+                  output_path=None, use_pro=False, aspect_ratio=None):
+    """Generate a logo using Gemini models with image generation
+
+    Args:
+        aspect_ratio: Image aspect ratio. Options: "1:1", "16:9", "9:16", "4:3", "3:4"
+                      Default is "1:1" (square) for logos.
+    """
+
+    if not GEMINI_API_KEY:
+        print("Error: GEMINI_API_KEY not set")
+        print("Set it with: export GEMINI_API_KEY='your-key'")
+        return None
+
+    # Initialize client
+    client = genai.Client(api_key=GEMINI_API_KEY)
+
+    # Enhance the prompt
+    full_prompt = enhance_prompt(prompt, style, industry, brand_name)
+
+    # Select model
+    model = GEMINI_PRO if use_pro else GEMINI_FLASH
+    model_label = "Nano Banana Pro (gemini-3-pro-image-preview)" if use_pro else "Nano Banana 2 (gemini-3.1-flash-image-preview)"
+
+    # Set aspect ratio (default to 1:1 for logos)
+    ratio = aspect_ratio if aspect_ratio in ASPECT_RATIOS else DEFAULT_ASPECT_RATIO
+
+    print(f"Generating logo with {model_label}...")
+    print(f"Aspect ratio: {ratio}")
+    print(f"Prompt: {full_prompt[:150]}...")
+    print()
+
+    try:
+        # Generate image using Gemini with image generation capability
+        response = client.models.generate_content(
+            model=model,
+            contents=full_prompt,
+            config=types.GenerateContentConfig(
+                response_modalities=["IMAGE", "TEXT"],
+                image_config=types.ImageConfig(
+                    aspect_ratio=ratio
+                ),
+                safety_settings=[
+                    types.SafetySetting(
+                        category="HARM_CATEGORY_HATE_SPEECH",
+                        threshold="BLOCK_LOW_AND_ABOVE"
+                    ),
+                    types.SafetySetting(
+                        category="HARM_CATEGORY_DANGEROUS_CONTENT",
+                        threshold="BLOCK_LOW_AND_ABOVE"
+                    ),
+                    types.SafetySetting(
+                        category="HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                        threshold="BLOCK_LOW_AND_ABOVE"
+                    ),
+                    types.SafetySetting(
+                        category="HARM_CATEGORY_HARASSMENT",
+                        threshold="BLOCK_LOW_AND_ABOVE"
+                    ),
+                ]
+            )
+        )
+
+        # Extract image from response
+        image_data = None
+        for part in response.candidates[0].content.parts:
+            if hasattr(part, 'inline_data') and part.inline_data:
+                if part.inline_data.mime_type.startswith('image/'):
+                    image_data = part.inline_data.data
+                    break
+
+        if not image_data:
+            print("No image generated. The model may not have produced an image.")
+            print("Try a different prompt or check if the model supports image generation.")
+            return None
+
+        # Determine output path
+        if output_path is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            brand_slug = brand_name.lower().replace(" ", "_") if brand_name else "logo"
+            output_path = f"{brand_slug}_{timestamp}.png"
+
+        # Save image
+        with open(output_path, "wb") as f:
+            f.write(image_data)
+
+        print(f"Logo saved to: {output_path}")
+        return output_path
+
+    except Exception as e:
+        print(f"Error generating logo: {e}")
+        return None
+
+
+def generate_batch(prompt, brand_name, count, output_dir, use_pro=False, brand_context=None, aspect_ratio=None):
+    """Generate multiple logo variants with different styles"""
+
+    # Select appropriate styles for batch generation
+    batch_styles = [
+        ("minimalist", "Clean, simple geometric shape with minimal details"),
+        ("modern", "Sleek gradient with tech-forward aesthetic"),
+        ("geometric", "Abstract geometric patterns, mathematical precision"),
+        ("gradient", "Vibrant color transitions, modern digital feel"),
+        ("abstract", "Conceptual symbolic representation"),
+        ("lettermark", "Stylized letter 'U' as monogram"),
+        ("negative-space", "Clever use of negative space, hidden meaning"),
+        ("lineart", "Single stroke continuous line design"),
+        ("3d", "Dimensional design with depth and shadows"),
+    ]
+
+    # Ensure output directory exists
+    os.makedirs(output_dir, exist_ok=True)
+
+    results = []
+    model_label = "Pro" if use_pro else "Flash"
+    ratio = aspect_ratio if aspect_ratio in ASPECT_RATIOS else DEFAULT_ASPECT_RATIO
+
+    print(f"\n{'='*60}")
+    print(f"  BATCH LOGO GENERATION: {brand_name}")
+    print(f"  Model: Nano Banana {model_label}")
+    print(f"  Aspect Ratio: {ratio}")
+    print(f"  Variants: {count}")
+    print(f"  Output: {output_dir}")
+    print(f"{'='*60}\n")
+
+    for i in range(min(count, len(batch_styles))):
+        style_key, style_desc = batch_styles[i]
+
+        # Build enhanced prompt with brand context
+        enhanced_prompt = f"{prompt}, {style_desc}"
+        if brand_context:
+            enhanced_prompt = f"{brand_context}, {enhanced_prompt}"
+
+        # Generate filename
+        filename = f"{brand_name.lower().replace(' ', '_')}_{style_key}_{i+1:02d}.png"
+        output_path = os.path.join(output_dir, filename)
+
+        print(f"[{i+1}/{count}] Generating {style_key} variant...")
+
+        result = generate_logo(
+            prompt=enhanced_prompt,
+            style=style_key,
+            industry="tech",
+            brand_name=brand_name,
+            output_path=output_path,
+            use_pro=use_pro,
+            aspect_ratio=aspect_ratio
+        )
+
+        if result:
+            results.append(result)
+            print(f"  ✓ Saved: {filename}\n")
+        else:
+            print(f"  ✗ Failed: {style_key}\n")
+
+        # Rate limiting between requests
+        if i < count - 1:
+            time.sleep(2)
+
+    print(f"\n{'='*60}")
+    print(f"  BATCH COMPLETE: {len(results)}/{count} logos generated")
+    print(f"{'='*60}\n")
+
+    return results
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate logos using Gemini Nano Banana models")
+    parser.add_argument("--prompt", "-p", type=str, help="Logo description prompt")
+    parser.add_argument("--brand", "-b", type=str, help="Brand name")
+    parser.add_argument("--style", "-s", choices=list(STYLE_MODIFIERS.keys()), help="Logo style")
+    parser.add_argument("--industry", "-i", choices=list(INDUSTRY_PROMPTS.keys()), help="Industry type")
+    parser.add_argument("--output", "-o", type=str, help="Output file path")
+    parser.add_argument("--output-dir", type=str, help="Output directory for batch generation")
+    parser.add_argument("--batch", type=int, help="Number of logo variants to generate (batch mode)")
+    parser.add_argument("--brand-context", type=str, help="Additional brand context for prompts")
+    parser.add_argument("--pro", action="store_true", help="Use Nano Banana Pro (gemini-3-pro-image-preview) for professional quality")
+    parser.add_argument("--aspect-ratio", "-r", choices=ASPECT_RATIOS, default=DEFAULT_ASPECT_RATIO,
+                        help=f"Image aspect ratio (default: {DEFAULT_ASPECT_RATIO} for logos)")
+    parser.add_argument("--list-styles", action="store_true", help="List available styles")
+    parser.add_argument("--list-industries", action="store_true", help="List available industries")
+
+    args = parser.parse_args()
+
+    if args.list_styles:
+        print("Available styles:")
+        for style, desc in STYLE_MODIFIERS.items():
+            print(f"  {style}: {desc[:60]}...")
+        return
+
+    if args.list_industries:
+        print("Available industries:")
+        for industry, desc in INDUSTRY_PROMPTS.items():
+            print(f"  {industry}: {desc[:60]}...")
+        return
+
+    if not args.prompt and not args.brand:
+        parser.error("Either --prompt or --brand is required")
+
+    prompt = args.prompt or "professional logo"
+
+    # Batch mode
+    if args.batch:
+        output_dir = args.output_dir or f"./{args.brand.lower().replace(' ', '_')}_logos"
+        generate_batch(
+            prompt=prompt,
+            brand_name=args.brand or "Logo",
+            count=args.batch,
+            output_dir=output_dir,
+            use_pro=args.pro,
+            brand_context=args.brand_context,
+            aspect_ratio=args.aspect_ratio
+        )
+    else:
+        generate_logo(
+            prompt=prompt,
+            style=args.style,
+            industry=args.industry,
+            brand_name=args.brand,
+            output_path=args.output,
+            use_pro=args.pro,
+            aspect_ratio=args.aspect_ratio
+        )
+
+
+if __name__ == "__main__":
+    main()

.opencode/skills/design/scripts/logo/search.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Logo Design Search - CLI for searching logo design guidelines
+Usage: python search.py "<query>" [--domain <domain>] [--max-results 3]
+       python search.py "<query>" --design-brief [-p "Brand Name"]
+
+Domains: style, color, industry
+"""
+
+import argparse
+from core import CSV_CONFIG, MAX_RESULTS, search, search_all
+
+
+def format_output(result):
+    """Format results for Claude consumption (token-optimized)"""
+    if "error" in result:
+        return f"Error: {result['error']}"
+
+    output = []
+    output.append(f"## Logo Design Search Results")
+    output.append(f"**Domain:** {result['domain']} | **Query:** {result['query']}")
+    output.append(f"**Source:** {result['file']} | **Found:** {result['count']} results\n")
+
+    for i, row in enumerate(result['results'], 1):
+        output.append(f"### Result {i}")
+        for key, value in row.items():
+            value_str = str(value)
+            if len(value_str) > 300:
+                value_str = value_str[:300] + "..."
+            output.append(f"- **{key}:** {value_str}")
+        output.append("")
+
+    return "\n".join(output)
+
+
+def generate_design_brief(query, brand_name=None):
+    """Generate a comprehensive logo design brief based on query"""
+    results = search_all(query, max_results=2)
+
+    output = []
+    output.append("=" * 60)
+    if brand_name:
+        output.append(f"  LOGO DESIGN BRIEF: {brand_name.upper()}")
+    else:
+        output.append("  LOGO DESIGN BRIEF")
+    output.append("=" * 60)
+    output.append(f"  Query: {query}")
+    output.append("=" * 60)
+    output.append("")
+
+    # Industry recommendations
+    if "industry" in results:
+        output.append("## INDUSTRY ANALYSIS")
+        for r in results["industry"]:
+            output.append(f"**Industry:** {r.get('Industry', 'N/A')}")
+            output.append(f"- Recommended Styles: {r.get('Recommended Styles', 'N/A')}")
+            output.append(f"- Colors: {r.get('Primary Colors', 'N/A')}")
+            output.append(f"- Typography: {r.get('Typography', 'N/A')}")
+            output.append(f"- Symbols: {r.get('Common Symbols', 'N/A')}")
+            output.append(f"- Mood: {r.get('Mood', 'N/A')}")
+            output.append(f"- Best Practices: {r.get('Best Practices', 'N/A')}")
+            output.append(f"- Avoid: {r.get('Avoid', 'N/A')}")
+            output.append("")
+
+    # Style recommendations
+    if "style" in results:
+        output.append("## STYLE RECOMMENDATIONS")
+        for r in results["style"]:
+            output.append(f"**{r.get('Style Name', 'N/A')}** ({r.get('Category', 'N/A')})")
+            output.append(f"- Colors: {r.get('Primary Colors', 'N/A')} | {r.get('Secondary Colors', 'N/A')}")
+            output.append(f"- Typography: {r.get('Typography', 'N/A')}")
+            output.append(f"- Effects: {r.get('Effects', 'N/A')}")
+            output.append(f"- Best For: {r.get('Best For', 'N/A')}")
+            output.append(f"- Complexity: {r.get('Complexity', 'N/A')}")
+            output.append("")
+
+    # Color recommendations
+    if "color" in results:
+        output.append("## COLOR PALETTE OPTIONS")
+        for r in results["color"]:
+            output.append(f"**{r.get('Palette Name', 'N/A')}**")
+            output.append(f"- Primary: {r.get('Primary Hex', 'N/A')}")
+            output.append(f"- Secondary: {r.get('Secondary Hex', 'N/A')}")
+            output.append(f"- Accent: {r.get('Accent Hex', 'N/A')}")
+            output.append(f"- Background: {r.get('Background Hex', 'N/A')}")
+            output.append(f"- Psychology: {r.get('Psychology', 'N/A')}")
+            output.append("")
+
+    output.append("=" * 60)
+    return "\n".join(output)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Logo Design Search")
+    parser.add_argument("query", help="Search query")
+    parser.add_argument("--domain", "-d", choices=list(CSV_CONFIG.keys()), help="Search domain")
+    parser.add_argument("--max-results", "-n", type=int, default=MAX_RESULTS, help="Max results (default: 3)")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    parser.add_argument("--design-brief", "-db", action="store_true", help="Generate comprehensive design brief")
+    parser.add_argument("--brand-name", "-p", type=str, default=None, help="Brand name for design brief")
+
+    args = parser.parse_args()
+
+    if args.design_brief:
+        result = generate_design_brief(args.query, args.brand_name)
+        print(result)
+    else:
+        result = search(args.query, args.domain, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(format_output(result))