@hienlh/ppm 0.9.81 → 0.9.82

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

@@ -1,487 +0,0 @@
-#!/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/.opencode/skills/design/scripts/logo/core.py

@@ -1,175 +0,0 @@
-#!/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