ui-ux-pro-max-cli 2.8.8

package/assets/skills/design/scripts/icon/generate.py

@@ -0,0 +1,487 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Icon Generation Script using Gemini 3.1 Pro Preview API
+Generates SVG icons via text generation (SVG is XML text format)
+
+Model: gemini-3.1-pro-preview - best thinking, token efficiency, factual consistency
+
+Usage:
+    python generate.py --prompt "settings gear icon" --style outlined
+    python generate.py --prompt "shopping cart" --style filled --color "#6366F1"
+    python generate.py --name "dashboard" --category navigation --style duotone
+    python generate.py --prompt "cloud upload" --batch 4 --output-dir ./icons
+    python generate.py --prompt "user profile" --sizes "16,24,32,48"
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+import time
+from pathlib import Path
+from datetime import datetime
+
+
+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")
+MODEL = "gemini-3.1-pro-preview"
+
+# Icon styles with SVG-specific instructions
+ICON_STYLES = {
+    "outlined": "outlined stroke icons, 2px stroke width, no fill, clean open paths",
+    "filled": "solid filled icons, no stroke, flat color fills, bold shapes",
+    "duotone": "duotone style with primary color at full opacity and secondary color at 30% opacity, layered shapes",
+    "thin": "thin line icons, 1px or 1.5px stroke width, delicate minimalist lines",
+    "bold": "bold thick line icons, 3px stroke width, heavy weight, impactful",
+    "rounded": "rounded icons with round line caps and joins, soft corners, friendly feel",
+    "sharp": "sharp angular icons, square line caps and mitered joins, precise edges",
+    "flat": "flat design icons, solid fills, no gradients or shadows, geometric simplicity",
+    "gradient": "linear or radial gradient fills, modern vibrant color transitions",
+    "glassmorphism": "glassmorphism style with semi-transparent fills, blur backdrop effect simulation, frosted glass",
+    "pixel": "pixel art style icons on a grid, retro 8-bit aesthetic, crisp edges",
+    "hand-drawn": "hand-drawn sketch style, slightly irregular strokes, organic feel, imperfect lines",
+    "isometric": "isometric 3D projection, 30-degree angles, dimensional depth",
+    "glyph": "simple glyph style, single solid shape, minimal detail, pictogram",
+    "animated-ready": "animated-ready SVG with named groups and IDs for CSS/JS animation targets",
+}
+
+ICON_CATEGORIES = {
+    "navigation": "arrows, menus, hamburger, chevrons, home, back, forward, breadcrumb",
+    "action": "edit, delete, save, download, upload, share, copy, paste, print, search",
+    "communication": "email, chat, phone, video call, notification, bell, message bubble",
+    "media": "play, pause, stop, skip, volume, microphone, camera, image, gallery",
+    "file": "document, folder, archive, attachment, cloud, database, storage",
+    "user": "person, group, avatar, profile, settings, lock, key, shield",
+    "commerce": "cart, bag, wallet, credit card, receipt, tag, gift, store",
+    "data": "chart, graph, analytics, dashboard, table, filter, sort, calendar",
+    "development": "code, terminal, bug, git, API, server, database, deploy",
+    "social": "heart, star, thumbs up, bookmark, flag, trophy, badge, crown",
+    "weather": "sun, moon, cloud, rain, snow, wind, thunder, temperature",
+    "map": "pin, location, compass, globe, route, directions, map marker",
+}
+
+# SVG generation prompt template
+SVG_PROMPT_TEMPLATE = """Generate a clean, production-ready SVG icon.
+
+Requirements:
+- Output ONLY valid SVG code, nothing else
+- ViewBox: "0 0 {viewbox} {viewbox}"
+- Use currentColor for strokes/fills (inherits CSS color)
+- No embedded fonts or text elements unless specifically requested
+- No raster images or external references
+- Optimized paths with minimal nodes
+- Accessible: include <title> element with icon description
+{style_instructions}
+{color_instructions}
+{size_instructions}
+
+Icon to generate: {prompt}
+
+Output the SVG code only, wrapped in ```svg``` code block."""
+
+SVG_BATCH_PROMPT_TEMPLATE = """Generate {count} distinct SVG icon variations for: {prompt}
+
+Requirements for EACH icon:
+- Output ONLY valid SVG code
+- ViewBox: "0 0 {viewbox} {viewbox}"
+- Use currentColor for strokes/fills (inherits CSS color)
+- No embedded fonts, raster images, or external references
+- Optimized paths with minimal nodes
+- Include <title> element with icon description
+{style_instructions}
+{color_instructions}
+
+Generate {count} different visual interpretations. Output each SVG in a separate ```svg``` code block.
+Label each variation (e.g., "Variation 1: [brief description]")."""
+
+
+def extract_svgs(text):
+    """Extract SVG code blocks from model response"""
+    svgs = []
+
+    # Try ```svg code blocks first
+    pattern = r'```svg\s*\n(.*?)```'
+    matches = re.findall(pattern, text, re.DOTALL)
+    if matches:
+        svgs.extend(matches)
+
+    # Fallback: try ```xml code blocks
+    if not svgs:
+        pattern = r'```xml\s*\n(.*?)```'
+        matches = re.findall(pattern, text, re.DOTALL)
+        svgs.extend(matches)
+
+    # Fallback: try bare <svg> tags
+    if not svgs:
+        pattern = r'(<svg[^>]*>.*?</svg>)'
+        matches = re.findall(pattern, text, re.DOTALL)
+        svgs.extend(matches)
+
+    # Clean up extracted SVGs
+    cleaned = []
+    for svg in svgs:
+        svg = svg.strip()
+        if not svg.startswith('<svg'):
+            # Try to find <svg> within the extracted text
+            match = re.search(r'(<svg[^>]*>.*?</svg>)', svg, re.DOTALL)
+            if match:
+                svg = match.group(1)
+            else:
+                continue
+        cleaned.append(svg)
+
+    return cleaned
+
+
+def apply_color(svg_code, color):
+    """Replace currentColor with specific color if provided"""
+    if color:
+        # Replace currentColor with the specified color
+        svg_code = svg_code.replace('currentColor', color)
+        # If no currentColor was present, add fill/stroke color
+        if color not in svg_code:
+            svg_code = svg_code.replace('<svg', f'<svg color="{color}"', 1)
+    return svg_code
+
+
+def apply_viewbox_size(svg_code, size):
+    """Adjust SVG viewBox to target size"""
+    if size:
+        # Update width/height attributes if present
+        svg_code = re.sub(r'width="[^"]*"', f'width="{size}"', svg_code)
+        svg_code = re.sub(r'height="[^"]*"', f'height="{size}"', svg_code)
+        # Add width/height if not present
+        if 'width=' not in svg_code:
+            svg_code = svg_code.replace('<svg', f'<svg width="{size}" height="{size}"', 1)
+    return svg_code
+
+
+def generate_icon(prompt, style=None, category=None, name=None,
+                  color=None, size=24, output_path=None, viewbox=24):
+    """Generate a single SVG icon using Gemini 3.1 Pro Preview"""
+
+    if not GEMINI_API_KEY:
+        print("Error: GEMINI_API_KEY not set")
+        print("Set it with: export GEMINI_API_KEY='your-key'")
+        return None
+
+    client = genai.Client(api_key=GEMINI_API_KEY)
+
+    # Build style instructions
+    style_instructions = ""
+    if style and style in ICON_STYLES:
+        style_instructions = f"- Style: {ICON_STYLES[style]}"
+
+    # Build color instructions
+    color_instructions = "- Use currentColor for all strokes and fills"
+    if color:
+        color_instructions = f"- Use color: {color} for primary elements, currentColor for secondary"
+
+    # Build size instructions
+    size_instructions = f"- Design for {size}px display size, optimize detail level accordingly"
+
+    # Build final prompt
+    icon_prompt = prompt
+    if category and category in ICON_CATEGORIES:
+        icon_prompt = f"{prompt} (category: {ICON_CATEGORIES[category]})"
+    if name:
+        icon_prompt = f"'{name}' icon: {icon_prompt}"
+
+    full_prompt = SVG_PROMPT_TEMPLATE.format(
+        prompt=icon_prompt,
+        viewbox=viewbox,
+        style_instructions=style_instructions,
+        color_instructions=color_instructions,
+        size_instructions=size_instructions
+    )
+
+    print(f"Generating icon with {MODEL}...")
+    print(f"Prompt: {prompt}")
+    if style:
+        print(f"Style: {style}")
+    print()
+
+    try:
+        response = client.models.generate_content(
+            model=MODEL,
+            contents=full_prompt,
+            config=types.GenerateContentConfig(
+                temperature=0.7,
+                max_output_tokens=4096,
+            )
+        )
+
+        # Extract SVG from response
+        response_text = response.text if hasattr(response, 'text') else ""
+        if not response_text:
+            for part in response.candidates[0].content.parts:
+                if hasattr(part, 'text') and part.text:
+                    response_text += part.text
+
+        svgs = extract_svgs(response_text)
+
+        if not svgs:
+            print("No valid SVG generated. Model response:")
+            print(response_text[:500])
+            return None
+
+        svg_code = svgs[0]
+
+        # Apply color if specified
+        svg_code = apply_color(svg_code, color)
+
+        # Apply size
+        svg_code = apply_viewbox_size(svg_code, size)
+
+        # Determine output path
+        if output_path is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            slug = name or prompt.split()[0] if prompt else "icon"
+            slug = re.sub(r'[^a-zA-Z0-9_-]', '_', slug.lower())
+            style_suffix = f"_{style}" if style else ""
+            output_path = f"{slug}{style_suffix}_{timestamp}.svg"
+
+        # Save SVG
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(svg_code)
+
+        print(f"Icon saved to: {output_path}")
+        return output_path
+
+    except Exception as e:
+        print(f"Error generating icon: {e}")
+        return None
+
+
+def generate_batch(prompt, count, output_dir, style=None, color=None,
+                   viewbox=24, name=None):
+    """Generate multiple icon variations"""
+
+    if not GEMINI_API_KEY:
+        print("Error: GEMINI_API_KEY not set")
+        return []
+
+    client = genai.Client(api_key=GEMINI_API_KEY)
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Build instructions
+    style_instructions = ""
+    if style and style in ICON_STYLES:
+        style_instructions = f"- Style: {ICON_STYLES[style]}"
+
+    color_instructions = "- Use currentColor for all strokes and fills"
+    if color:
+        color_instructions = f"- Use color: {color} for primary elements"
+
+    full_prompt = SVG_BATCH_PROMPT_TEMPLATE.format(
+        prompt=prompt,
+        count=count,
+        viewbox=viewbox,
+        style_instructions=style_instructions,
+        color_instructions=color_instructions
+    )
+
+    print(f"\n{'='*60}")
+    print(f"  BATCH ICON GENERATION")
+    print(f"  Model: {MODEL}")
+    print(f"  Prompt: {prompt}")
+    print(f"  Variants: {count}")
+    print(f"  Output: {output_dir}")
+    print(f"{'='*60}\n")
+
+    try:
+        response = client.models.generate_content(
+            model=MODEL,
+            contents=full_prompt,
+            config=types.GenerateContentConfig(
+                temperature=0.9,
+                max_output_tokens=16384,
+            )
+        )
+
+        response_text = response.text if hasattr(response, 'text') else ""
+        if not response_text:
+            for part in response.candidates[0].content.parts:
+                if hasattr(part, 'text') and part.text:
+                    response_text += part.text
+
+        svgs = extract_svgs(response_text)
+
+        if not svgs:
+            print("No valid SVGs generated.")
+            print(response_text[:500])
+            return []
+
+        results = []
+        slug = name or re.sub(r'[^a-zA-Z0-9_-]', '_', prompt.split()[0].lower())
+        style_suffix = f"_{style}" if style else ""
+
+        for i, svg_code in enumerate(svgs[:count]):
+            svg_code = apply_color(svg_code, color)
+            filename = f"{slug}{style_suffix}_{i+1:02d}.svg"
+            filepath = os.path.join(output_dir, filename)
+
+            with open(filepath, "w", encoding="utf-8") as f:
+                f.write(svg_code)
+
+            results.append(filepath)
+            print(f"  [{i+1}/{len(svgs[:count])}] Saved: {filename}")
+
+        print(f"\n{'='*60}")
+        print(f"  BATCH COMPLETE: {len(results)}/{count} icons generated")
+        print(f"{'='*60}\n")
+
+        return results
+
+    except Exception as e:
+        print(f"Error generating icons: {e}")
+        return []
+
+
+def generate_sizes(prompt, sizes, style=None, color=None, output_dir=None, name=None):
+    """Generate same icon at multiple sizes"""
+    if output_dir is None:
+        output_dir = "."
+    os.makedirs(output_dir, exist_ok=True)
+
+    results = []
+    slug = name or re.sub(r'[^a-zA-Z0-9_-]', '_', prompt.split()[0].lower())
+    style_suffix = f"_{style}" if style else ""
+
+    for size in sizes:
+        print(f"Generating {size}px variant...")
+        filename = f"{slug}{style_suffix}_{size}px.svg"
+        filepath = os.path.join(output_dir, filename)
+
+        result = generate_icon(
+            prompt=prompt,
+            style=style,
+            color=color,
+            size=size,
+            output_path=filepath,
+            viewbox=size
+        )
+
+        if result:
+            results.append(result)
+
+        time.sleep(1)
+
+    return results
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate SVG icons using Gemini 3.1 Pro Preview"
+    )
+    parser.add_argument("--prompt", "-p", type=str, help="Icon description")
+    parser.add_argument("--name", "-n", type=str, help="Icon name (for filename)")
+    parser.add_argument("--style", "-s", choices=list(ICON_STYLES.keys()),
+                        help="Icon style")
+    parser.add_argument("--category", "-c", choices=list(ICON_CATEGORIES.keys()),
+                        help="Icon category for context")
+    parser.add_argument("--color", type=str,
+                        help="Primary color (hex, e.g. #6366F1). Default: currentColor")
+    parser.add_argument("--size", type=int, default=24,
+                        help="Icon size in px (default: 24)")
+    parser.add_argument("--viewbox", type=int, default=24,
+                        help="SVG viewBox size (default: 24)")
+    parser.add_argument("--output", "-o", type=str, help="Output file path")
+    parser.add_argument("--output-dir", type=str, help="Output directory for batch")
+    parser.add_argument("--batch", type=int,
+                        help="Number of icon variants to generate")
+    parser.add_argument("--sizes", type=str,
+                        help="Comma-separated sizes (e.g. '16,24,32,48')")
+    parser.add_argument("--list-styles", action="store_true",
+                        help="List available icon styles")
+    parser.add_argument("--list-categories", action="store_true",
+                        help="List available icon categories")
+
+    args = parser.parse_args()
+
+    if args.list_styles:
+        print("Available icon styles:")
+        for style, desc in ICON_STYLES.items():
+            print(f"  {style}: {desc[:70]}...")
+        return
+
+    if args.list_categories:
+        print("Available icon categories:")
+        for cat, desc in ICON_CATEGORIES.items():
+            print(f"  {cat}: {desc}")
+        return
+
+    if not args.prompt and not args.name:
+        parser.error("Either --prompt or --name is required")
+
+    prompt = args.prompt or args.name
+
+    # Multi-size mode
+    if args.sizes:
+        sizes = [int(s.strip()) for s in args.sizes.split(",")]
+        generate_sizes(
+            prompt=prompt,
+            sizes=sizes,
+            style=args.style,
+            color=args.color,
+            output_dir=args.output_dir or "./icons",
+            name=args.name
+        )
+    # Batch mode
+    elif args.batch:
+        output_dir = args.output_dir or "./icons"
+        generate_batch(
+            prompt=prompt,
+            count=args.batch,
+            output_dir=output_dir,
+            style=args.style,
+            color=args.color,
+            viewbox=args.viewbox,
+            name=args.name
+        )
+    # Single icon
+    else:
+        generate_icon(
+            prompt=prompt,
+            style=args.style,
+            category=args.category,
+            name=args.name,
+            color=args.color,
+            size=args.size,
+            output_path=args.output,
+            viewbox=args.viewbox
+        )
+
+
+if __name__ == "__main__":
+    main()

package/assets/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