cue-ai 0.9.2 → 0.9.4

package/resources/skills/skills/design/banana/scripts/cost_tracker.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""Banana Claude -- Cost Tracker
+
+Track image generation costs, view summaries, and estimate batch costs.
+
+Usage:
+    cost_tracker.py log --model MODEL --resolution RES --prompt "summary"
+    cost_tracker.py summary
+    cost_tracker.py today
+    cost_tracker.py estimate --model MODEL --resolution RES --count N
+    cost_tracker.py reset --confirm
+"""
+
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+LEDGER_PATH = Path.home() / ".banana" / "costs.json"
+
+# Cost per image in USD (approximate, based on ~1,290 output tokens)
+PRICING = {
+    "gemini-3.1-flash-image-preview": {
+        "512": 0.020,
+        "1K": 0.039,
+        "2K": 0.078,
+        "4K": 0.156,
+    },
+    "gemini-2.5-flash-image": {
+        "512": 0.020,
+        "1K": 0.039,
+    },
+}
+
+# Batch API gets 50% discount
+BATCH_DISCOUNT = 0.5
+
+
+def _load_ledger():
+    """Load the cost ledger from disk."""
+    if not LEDGER_PATH.exists():
+        return {"total_cost": 0.0, "total_images": 0, "entries": [], "daily": {}}
+    with open(LEDGER_PATH, "r") as f:
+        return json.load(f)
+
+
+def _save_ledger(ledger):
+    """Save the cost ledger to disk."""
+    LEDGER_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(LEDGER_PATH, "w") as f:
+        json.dump(ledger, f, indent=2)
+
+
+def _lookup_cost(model, resolution, batch=False):
+    """Look up cost for a model+resolution combination."""
+    model_pricing = PRICING.get(model)
+    if not model_pricing:
+        # Try partial match
+        for key in PRICING:
+            if key in model or model in key:
+                model_pricing = PRICING[key]
+                break
+    if not model_pricing:
+        print(f"Warning: Unknown model '{model}', using 3.1 Flash pricing", file=sys.stderr)
+        model_pricing = PRICING["gemini-3.1-flash-image-preview"]
+
+    valid_resolutions = {"512", "1K", "2K", "4K"}
+    if resolution not in valid_resolutions:
+        print(f"Warning: Unknown resolution '{resolution}', using 1K pricing", file=sys.stderr)
+    cost = model_pricing.get(resolution, model_pricing.get("1K", 0.039))
+    if batch:
+        cost *= BATCH_DISCOUNT
+    return cost
+
+
+def cmd_log(args):
+    """Log a generation to the ledger."""
+    ledger = _load_ledger()
+    cost = _lookup_cost(args.model, args.resolution, getattr(args, "batch", False))
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S")
+
+    entry = {
+        "ts": now,
+        "model": args.model,
+        "res": args.resolution,
+        "cost": cost,
+        "prompt": args.prompt[:100],
+    }
+
+    ledger["entries"].append(entry)
+    ledger["total_cost"] = round(ledger["total_cost"] + cost, 4)
+    ledger["total_images"] += 1
+
+    if today not in ledger["daily"]:
+        ledger["daily"][today] = {"count": 0, "cost": 0.0}
+    ledger["daily"][today]["count"] += 1
+    ledger["daily"][today]["cost"] = round(ledger["daily"][today]["cost"] + cost, 4)
+
+    _save_ledger(ledger)
+    print(json.dumps({"logged": True, "cost": cost, "total_cost": ledger["total_cost"],
+                       "total_images": ledger["total_images"]}))
+
+
+def cmd_summary(args):
+    """Show cost summary."""
+    ledger = _load_ledger()
+    print(f"Total images: {ledger['total_images']}")
+    print(f"Total cost:   ${ledger['total_cost']:.3f}")
+    print()
+
+    daily = ledger.get("daily", {})
+    if daily:
+        # Show last 7 days
+        sorted_days = sorted(daily.keys(), reverse=True)[:7]
+        print("Last 7 days:")
+        for day in sorted_days:
+            d = daily[day]
+            print(f"  {day}: {d['count']} images, ${d['cost']:.3f}")
+    else:
+        print("No usage recorded yet.")
+
+
+def cmd_today(args):
+    """Show today's usage."""
+    ledger = _load_ledger()
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    daily = ledger.get("daily", {}).get(today, {"count": 0, "cost": 0.0})
+    print(f"Today ({today}): {daily['count']} images, ${daily['cost']:.3f}")
+
+
+def cmd_estimate(args):
+    """Estimate cost for a batch."""
+    cost_per = _lookup_cost(args.model, args.resolution, getattr(args, "batch", False))
+    total = round(cost_per * args.count, 3)
+    print(f"Model:      {args.model}")
+    print(f"Resolution: {args.resolution}")
+    print(f"Count:      {args.count}")
+    print(f"Cost/image: ${cost_per:.3f}")
+    print(f"Total est:  ${total:.3f}")
+    if not getattr(args, "batch", False):
+        batch_total = round(cost_per * BATCH_DISCOUNT * args.count, 3)
+        print(f"Batch est:  ${batch_total:.3f} (50% discount)")
+
+
+def cmd_reset(args):
+    """Reset the ledger."""
+    if not args.confirm:
+        print("Error: Pass --confirm to reset the cost ledger.", file=sys.stderr)
+        sys.exit(1)
+    _save_ledger({"total_cost": 0.0, "total_images": 0, "entries": [], "daily": {}})
+    print("Cost ledger reset.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Banana Claude Cost Tracker")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # log
+    p_log = sub.add_parser("log", help="Log a generation")
+    p_log.add_argument("--model", required=True, help="Model ID")
+    p_log.add_argument("--resolution", required=True, help="Resolution (512, 1K, 2K, 4K)")
+    p_log.add_argument("--prompt", required=True, help="Brief prompt description")
+    p_log.add_argument("--batch", action="store_true", help="Batch API (50%% discount)")
+
+    # summary
+    sub.add_parser("summary", help="Show cost summary")
+
+    # today
+    sub.add_parser("today", help="Show today's usage")
+
+    # estimate
+    p_est = sub.add_parser("estimate", help="Estimate batch cost")
+    p_est.add_argument("--model", required=True, help="Model ID")
+    p_est.add_argument("--resolution", required=True, help="Resolution (512, 1K, 2K, 4K)")
+    p_est.add_argument("--count", required=True, type=int, help="Number of images")
+    p_est.add_argument("--batch", action="store_true", help="Use batch pricing (50%% discount)")
+
+    # reset
+    p_reset = sub.add_parser("reset", help="Reset cost ledger")
+    p_reset.add_argument("--confirm", action="store_true", help="Confirm reset")
+
+    args = parser.parse_args()
+    cmds = {"log": cmd_log, "summary": cmd_summary, "today": cmd_today,
+            "estimate": cmd_estimate, "reset": cmd_reset}
+    cmds[args.command](args)
+
+
+if __name__ == "__main__":
+    main()

package/resources/skills/skills/design/banana/scripts/edit.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""Banana Claude -- Direct API Fallback: Image Editing
+
+Edit images via Gemini REST API when MCP is unavailable.
+Uses only Python stdlib (no pip dependencies).
+
+Usage:
+    edit.py --image path/to/image.png --prompt "remove the background"
+            [--model MODEL] [--api-key KEY]
+"""
+
+import argparse
+import base64
+import json
+import os
+import sys
+import time
+import urllib.request
+from datetime import datetime
+from pathlib import Path
+
+DEFAULT_MODEL = "gemini-3.1-flash-image-preview"
+OUTPUT_DIR = Path.home() / "Documents" / "nanobanana_generated"
+API_BASE = "https://generativelanguage.googleapis.com/v1beta/models"
+
+
+def edit_image(image_path, prompt, model, api_key):
+    """Call Gemini API to edit an image."""
+    image_path = Path(image_path).resolve()
+    if not image_path.exists():
+        print(json.dumps({"error": True, "message": f"Image not found: {image_path}"}))
+        sys.exit(1)
+
+    # Read and encode image
+    with open(image_path, "rb") as f:
+        image_b64 = base64.b64encode(f.read()).decode("utf-8")
+
+    # Determine MIME type
+    suffix = image_path.suffix.lower()
+    mime_types = {".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+                  ".webp": "image/webp", ".gif": "image/gif"}
+    mime_type = mime_types.get(suffix, "image/png")
+
+    url = f"{API_BASE}/{model}:generateContent?key={api_key}"
+
+    body = {
+        "contents": [
+            {
+                "parts": [
+                    {"text": prompt},
+                    {"inlineData": {"mimeType": mime_type, "data": image_b64}},
+                ]
+            }
+        ],
+        "generationConfig": {
+            "responseModalities": ["TEXT", "IMAGE"],
+        },
+    }
+
+    data = json.dumps(body).encode("utf-8")
+    req = urllib.request.Request(
+        url,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+
+    max_retries = 3
+    result = None
+    for attempt in range(max_retries):
+        try:
+            with urllib.request.urlopen(req, timeout=120) as resp:
+                result = json.loads(resp.read().decode("utf-8"))
+            break  # Success
+        except urllib.error.HTTPError as e:
+            error_body = e.read().decode("utf-8") if e.fp else ""
+            if e.code == 429 and attempt < max_retries - 1:
+                wait = 2 ** (attempt + 1)
+                print(json.dumps({"retry": True, "attempt": attempt + 1, "wait_seconds": wait, "reason": "rate_limited"}), file=sys.stderr)
+                time.sleep(wait)
+                req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"}, method="POST")
+                continue
+            if e.code == 400 and "FAILED_PRECONDITION" in error_body:
+                print(json.dumps({"error": True, "status": 400, "message": "Billing not enabled. Enable billing at https://aistudio.google.com/apikey"}))
+                sys.exit(1)
+            print(json.dumps({"error": True, "status": e.code, "message": error_body}))
+            sys.exit(1)
+        except urllib.error.URLError as e:
+            print(json.dumps({"error": True, "message": str(e.reason)}))
+            sys.exit(1)
+
+    if result is None:
+        print(json.dumps({"error": True, "message": "Max retries exceeded"}))
+        sys.exit(1)
+
+    # Extract image from response
+    candidates = result.get("candidates", [])
+    if not candidates:
+        finish_reason = result.get("promptFeedback", {}).get("blockReason", "UNKNOWN")
+        print(json.dumps({"error": True, "message": f"No candidates returned. Reason: {finish_reason}"}))
+        sys.exit(1)
+
+    parts = candidates[0].get("content", {}).get("parts", [])
+    image_data = None
+    text_response = ""
+
+    for part in parts:
+        if "inlineData" in part:
+            image_data = part["inlineData"]["data"]
+        elif "text" in part:
+            text_response = part["text"]
+
+    if not image_data:
+        finish_reason = candidates[0].get("finishReason", "UNKNOWN")
+        print(json.dumps({"error": True, "message": f"No image in response. finishReason: {finish_reason}"}))
+        sys.exit(1)
+
+    # Save image
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    filename = f"banana_edit_{timestamp}.png"
+    output_path = (OUTPUT_DIR / filename).resolve()
+
+    with open(output_path, "wb") as f:
+        f.write(base64.b64decode(image_data))
+
+    return {
+        "path": str(output_path),
+        "model": model,
+        "source": str(image_path),
+        "text": text_response,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Edit images via Gemini REST API")
+    parser.add_argument("--image", required=True, help="Path to input image")
+    parser.add_argument("--prompt", required=True, help="Edit instruction")
+    parser.add_argument("--model", default=DEFAULT_MODEL, help=f"Model ID (default: {DEFAULT_MODEL})")
+    parser.add_argument("--api-key", default=None, help="Google AI API key (or set GOOGLE_AI_API_KEY env)")
+
+    args = parser.parse_args()
+
+    api_key = args.api_key or os.environ.get("GOOGLE_AI_API_KEY") or os.environ.get("GOOGLE_API_KEY")
+    if not api_key:
+        print(json.dumps({"error": True, "message": "No API key. Set GOOGLE_AI_API_KEY env or pass --api-key"}))
+        sys.exit(1)
+
+    result = edit_image(
+        image_path=args.image,
+        prompt=args.prompt,
+        model=args.model,
+        api_key=api_key,
+    )
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/resources/skills/skills/design/banana/scripts/generate.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""Banana Claude -- Direct API Fallback: Image Generation
+
+Generate images via Gemini REST API when MCP is unavailable.
+Uses only Python stdlib (no pip dependencies).
+
+Usage:
+    generate.py --prompt "a cat in space" [--aspect-ratio 16:9] [--resolution 1K]
+                [--model MODEL] [--api-key KEY] [--thinking LEVEL] [--image-only]
+"""
+
+import argparse
+import base64
+import json
+import os
+import sys
+import time
+import urllib.request
+from datetime import datetime
+from pathlib import Path
+
+DEFAULT_MODEL = "gemini-3.1-flash-image-preview"
+DEFAULT_RESOLUTION = "2K"  # Must be uppercase -- lowercase values are silently rejected by the API
+DEFAULT_RATIO = "1:1"
+OUTPUT_DIR = Path.home() / "Documents" / "nanobanana_generated"
+API_BASE = "https://generativelanguage.googleapis.com/v1beta/models"
+
+VALID_RATIOS = {"1:1", "16:9", "9:16", "4:3", "3:4", "2:3", "3:2",
+                "4:5", "5:4", "1:4", "4:1", "1:8", "8:1", "21:9"}
+VALID_RESOLUTIONS = {"512", "1K", "2K", "4K"}
+
+
+def generate_image(prompt, model, aspect_ratio, resolution, api_key,
+                   thinking_level=None, image_only=False):
+    """Call Gemini API to generate an image."""
+    url = f"{API_BASE}/{model}:generateContent?key={api_key}"
+
+    modalities = ["IMAGE"] if image_only else ["TEXT", "IMAGE"]
+    body = {
+        "contents": [{"parts": [{"text": prompt}]}],
+        "generationConfig": {
+            "responseModalities": modalities,
+            "imageConfig": {
+                "aspectRatio": aspect_ratio,
+                "imageSize": resolution,
+            },
+        },
+    }
+
+    if thinking_level:
+        body["generationConfig"]["thinkingConfig"] = {"thinkingLevel": thinking_level}
+
+    data = json.dumps(body).encode("utf-8")
+    req = urllib.request.Request(
+        url,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+
+    max_retries = 3
+    result = None
+    for attempt in range(max_retries):
+        try:
+            with urllib.request.urlopen(req, timeout=120) as resp:
+                result = json.loads(resp.read().decode("utf-8"))
+            break  # Success
+        except urllib.error.HTTPError as e:
+            error_body = e.read().decode("utf-8") if e.fp else ""
+            if e.code == 429 and attempt < max_retries - 1:
+                wait = 2 ** (attempt + 1)
+                print(json.dumps({"retry": True, "attempt": attempt + 1, "wait_seconds": wait, "reason": "rate_limited"}), file=sys.stderr)
+                time.sleep(wait)
+                # Rebuild request for retry
+                req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"}, method="POST")
+                continue
+            if e.code == 400 and "FAILED_PRECONDITION" in error_body:
+                print(json.dumps({"error": True, "status": 400, "message": "Billing not enabled. Enable billing at https://aistudio.google.com/apikey"}))
+                sys.exit(1)
+            print(json.dumps({"error": True, "status": e.code, "message": error_body}))
+            sys.exit(1)
+        except urllib.error.URLError as e:
+            print(json.dumps({"error": True, "message": str(e.reason)}))
+            sys.exit(1)
+
+    if result is None:
+        print(json.dumps({"error": True, "message": "Max retries exceeded"}))
+        sys.exit(1)
+
+    # Extract image from response
+    candidates = result.get("candidates", [])
+    if not candidates:
+        finish_reason = result.get("promptFeedback", {}).get("blockReason", "UNKNOWN")
+        print(json.dumps({"error": True, "message": f"No candidates returned. Reason: {finish_reason}"}))
+        sys.exit(1)
+
+    parts = candidates[0].get("content", {}).get("parts", [])
+    image_data = None
+    text_response = ""
+
+    for part in parts:
+        if "inlineData" in part:
+            image_data = part["inlineData"]["data"]
+        elif "text" in part:
+            text_response = part["text"]
+
+    if not image_data:
+        finish_reason = candidates[0].get("finishReason", "UNKNOWN")
+        print(json.dumps({"error": True, "message": f"No image in response. finishReason: {finish_reason}"}))
+        sys.exit(1)
+
+    # Save image
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    filename = f"banana_{timestamp}.png"
+    output_path = (OUTPUT_DIR / filename).resolve()
+
+    with open(output_path, "wb") as f:
+        f.write(base64.b64decode(image_data))
+
+    return {
+        "path": str(output_path),
+        "model": model,
+        "aspect_ratio": aspect_ratio,
+        "resolution": resolution,
+        "text": text_response,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate images via Gemini REST API")
+    parser.add_argument("--prompt", required=True, help="Image generation prompt")
+    parser.add_argument("--aspect-ratio", default=DEFAULT_RATIO, help=f"Aspect ratio (default: {DEFAULT_RATIO})")
+    parser.add_argument("--resolution", default=DEFAULT_RESOLUTION, help=f"Resolution: 512, 1K, 2K, 4K (default: {DEFAULT_RESOLUTION})")
+    parser.add_argument("--model", default=DEFAULT_MODEL, help=f"Model ID (default: {DEFAULT_MODEL})")
+    parser.add_argument("--api-key", default=None, help="Google AI API key (or set GOOGLE_AI_API_KEY env)")
+    parser.add_argument("--thinking", default=None, choices=["minimal", "low", "medium", "high"], help="Thinking level")
+    parser.add_argument("--image-only", action="store_true", help="Return image only (no text)")
+
+    args = parser.parse_args()
+
+    if args.aspect_ratio not in VALID_RATIOS:
+        print(json.dumps({"error": True, "message": f"Invalid aspect ratio '{args.aspect_ratio}'. Valid: {sorted(VALID_RATIOS)}"}))
+        sys.exit(1)
+
+    if args.resolution not in VALID_RESOLUTIONS:
+        print(json.dumps({"error": True, "message": f"Invalid resolution '{args.resolution}'. Valid: {sorted(VALID_RESOLUTIONS)}"}))
+        sys.exit(1)
+
+    api_key = args.api_key or os.environ.get("GOOGLE_AI_API_KEY") or os.environ.get("GOOGLE_API_KEY")
+    if not api_key:
+        print(json.dumps({"error": True, "message": "No API key. Set GOOGLE_AI_API_KEY env or pass --api-key"}))
+        sys.exit(1)
+
+    result = generate_image(
+        prompt=args.prompt,
+        model=args.model,
+        aspect_ratio=args.aspect_ratio,
+        resolution=args.resolution,
+        api_key=api_key,
+        thinking_level=args.thinking,
+        image_only=args.image_only,
+    )
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/resources/skills/skills/design/banana/scripts/presets.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Banana Claude -- Brand/Style Presets
+
+Manage reusable brand and style presets for consistent image generation.
+
+Usage:
+    presets.py list
+    presets.py show NAME
+    presets.py create NAME --colors "#hex,#hex" --style "..." [options]
+    presets.py delete NAME --confirm
+"""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+PRESETS_DIR = Path.home() / ".banana" / "presets"
+
+
+def _ensure_dir():
+    """Ensure presets directory exists."""
+    PRESETS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _sanitize_name(name):
+    """Sanitize preset name to prevent path traversal."""
+    # Strip path separators and keep only safe characters
+    safe = re.sub(r'[^a-zA-Z0-9_\-]', '', name)
+    if not safe:
+        print("Error: Preset name must contain only letters, numbers, hyphens, and underscores.", file=sys.stderr)
+        sys.exit(1)
+    return safe
+
+
+def _preset_path(name):
+    """Get path for a preset file."""
+    safe_name = _sanitize_name(name)
+    return PRESETS_DIR / f"{safe_name}.json"
+
+
+def _load_preset(name):
+    """Load a preset by name."""
+    path = _preset_path(name)
+    if not path.exists():
+        print(f"Error: Preset '{name}' not found.", file=sys.stderr)
+        sys.exit(1)
+    with open(path, "r") as f:
+        return json.load(f)
+
+
+def cmd_list(args):
+    """List available presets."""
+    _ensure_dir()
+    presets = sorted(PRESETS_DIR.glob("*.json"))
+    if not presets:
+        print("No presets found. Create one with: presets.py create NAME --style \"...\"")
+        return
+    print(f"Available presets ({len(presets)}):\n")
+    for p in presets:
+        try:
+            with open(p, "r") as f:
+                data = json.load(f)
+            desc = data.get("description", "No description")
+            print(f"  {p.stem:20s} -- {desc}")
+        except (json.JSONDecodeError, KeyError):
+            print(f"  {p.stem:20s} -- (invalid preset file)")
+
+
+def cmd_show(args):
+    """Show full preset details."""
+    preset = _load_preset(args.name)
+    print(json.dumps(preset, indent=2))
+
+
+def cmd_create(args):
+    """Create a new preset."""
+    _ensure_dir()
+    path = _preset_path(args.name)
+    if path.exists():
+        print(f"Error: Preset '{args.name}' already exists. Use a different name.", file=sys.stderr)
+        sys.exit(1)
+
+    colors = [c.strip() for c in args.colors.split(",")] if args.colors else []
+
+    preset = {
+        "name": args.name,
+        "description": args.description or f"Custom preset: {args.name}",
+        "colors": colors,
+        "style": args.style or "",
+        "typography": args.typography or "",
+        "lighting": args.lighting or "",
+        "mood": args.mood or "",
+        "default_ratio": args.ratio or "16:9",
+        "default_resolution": args.resolution or "2K",
+    }
+
+    with open(path, "w") as f:
+        json.dump(preset, f, indent=2)
+
+    print(f"Preset '{args.name}' created at {path}")
+    print(json.dumps(preset, indent=2))
+
+
+def cmd_delete(args):
+    """Delete a preset."""
+    if not args.confirm:
+        print("Error: Pass --confirm to delete the preset.", file=sys.stderr)
+        sys.exit(1)
+    path = _preset_path(args.name)
+    if not path.exists():
+        print(f"Error: Preset '{args.name}' not found.", file=sys.stderr)
+        sys.exit(1)
+    path.unlink()
+    print(f"Preset '{args.name}' deleted.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Banana Claude Brand/Style Presets")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # list
+    sub.add_parser("list", help="List available presets")
+
+    # show
+    p_show = sub.add_parser("show", help="Show preset details")
+    p_show.add_argument("name", help="Preset name")
+
+    # create
+    p_create = sub.add_parser("create", help="Create a new preset")
+    p_create.add_argument("name", help="Preset name (e.g., tech-saas, luxury-brand)")
+    p_create.add_argument("--colors", default="", help="Comma-separated hex colors")
+    p_create.add_argument("--style", default="", help="Visual style description")
+    p_create.add_argument("--typography", default="", help="Typography description")
+    p_create.add_argument("--lighting", default="", help="Lighting description")
+    p_create.add_argument("--mood", default="", help="Mood/emotion description")
+    p_create.add_argument("--description", default="", help="Brief preset description")
+    p_create.add_argument("--ratio", default="16:9", help="Default aspect ratio")
+    p_create.add_argument("--resolution", default="2K", help="Default resolution")
+    p_create.add_argument("--force", action="store_true", help="Overwrite existing preset")
+
+    # delete
+    p_delete = sub.add_parser("delete", help="Delete a preset")
+    p_delete.add_argument("name", help="Preset name")
+    p_delete.add_argument("--confirm", action="store_true", help="Confirm deletion")
+
+    args = parser.parse_args()
+    cmds = {"list": cmd_list, "show": cmd_show, "create": cmd_create, "delete": cmd_delete}
+    cmds[args.command](args)
+
+
+if __name__ == "__main__":
+    main()