antigravity-seo-kit 2.0.0

package/.agent/skills/seo-image-gen/references/seo-image-presets.md

@@ -0,0 +1,137 @@
+# SEO Image Presets
+
+Pre-configured presets for common SEO image use cases. These map to banana's
+preset format (see `references/presets.md` for schema details).
+
+## Preset Templates
+
+### og-default:Standard OG/Social Preview
+
+```json
+{
+  "name": "og-default",
+  "description": "Clean, professional OG image for social sharing",
+  "aspect_ratio": "16:9",
+  "resolution": "1K",
+  "domain_mode": "Product",
+  "style": {
+    "colors": ["#FFFFFF", "#F5F5F5"],
+    "mood": "Professional, clean, trustworthy",
+    "lighting": "Bright, even studio lighting with soft shadows",
+    "typography": "Modern sans-serif if text needed"
+  },
+  "post_processing": "magick output.png -resize 1200x630^ -gravity center -extent 1200x630 output-og.webp"
+}
+```
+
+### blog-hero:Widescreen Blog Hero Image
+
+```json
+{
+  "name": "blog-hero",
+  "description": "Dramatic widescreen hero for blog posts",
+  "aspect_ratio": "16:9",
+  "resolution": "2K",
+  "domain_mode": "Cinema",
+  "style": {
+    "colors": ["contextual"],
+    "mood": "Dramatic, atmospheric, editorial",
+    "lighting": "Golden hour or moody blue hour, directional",
+    "typography": "None:image only"
+  },
+  "post_processing": "magick output.png -quality 85 output-hero.webp"
+}
+```
+
+### product-white:E-commerce Product Shot
+
+```json
+{
+  "name": "product-white",
+  "description": "Clean white background product photography",
+  "aspect_ratio": "4:3",
+  "resolution": "2K",
+  "domain_mode": "Product",
+  "style": {
+    "colors": ["#FFFFFF"],
+    "mood": "Clean, professional, catalog-ready",
+    "lighting": "360-degree soft studio lighting, minimal shadows",
+    "typography": "None"
+  },
+  "prompt_suffix": "Studio product photography, clean white background, professional catalog shot, high resolution",
+  "post_processing": "magick output.png -fuzz 5% -transparent white output-transparent.png"
+}
+```
+
+### social-square:Social Media Square
+
+```json
+{
+  "name": "social-square",
+  "description": "1:1 square image for social media platforms",
+  "aspect_ratio": "1:1",
+  "resolution": "1K",
+  "domain_mode": "UI/Web",
+  "style": {
+    "colors": ["brand-contextual"],
+    "mood": "Engaging, scroll-stopping, platform-native",
+    "lighting": "Bright, even, high-contrast",
+    "typography": "Bold sans-serif if text needed, under 25 characters"
+  }
+}
+```
+
+### infographic-vertical:Data-Heavy Infographic
+
+```json
+{
+  "name": "infographic-vertical",
+  "description": "Tall vertical infographic for data visualization",
+  "aspect_ratio": "2:3",
+  "resolution": "4K",
+  "domain_mode": "Infographic",
+  "style": {
+    "colors": ["brand-contextual", "data-visualization palette"],
+    "mood": "Informative, structured, authoritative",
+    "lighting": "Flat, even, no dramatic shadows",
+    "typography": "Clear hierarchy:headline, subheads, body, captions"
+  },
+  "notes": "Use thinking: high for better text rendering accuracy"
+}
+```
+
+### favicon-mark:Favicon / App Icon
+
+```json
+{
+  "name": "favicon-mark",
+  "description": "Minimal iconic mark for favicon or app icon",
+  "aspect_ratio": "1:1",
+  "resolution": "512",
+  "domain_mode": "Logo",
+  "style": {
+    "colors": ["2-3 brand colors max"],
+    "mood": "Minimal, recognizable, scalable",
+    "lighting": "Flat, no shadows",
+    "typography": "Single letter or symbol only"
+  },
+  "post_processing": "magick output.png -resize 32x32 favicon.ico && magick output.png -resize 180x180 apple-touch-icon.png"
+}
+```
+
+## Creating Custom Presets
+
+Users can create their own presets:
+```bash
+python3 .agent/skills/seo-image-gen/scripts/presets.py create my-brand
+```
+
+This creates `~/.banana/presets/my-brand.json` with the full schema.
+Custom presets override SEO defaults when specified.
+
+## Preset Selection Logic
+
+1. If user specifies a use case command (og, hero, product), load the matching preset
+2. If user mentions a brand preset name, load from `~/.banana/presets/`
+3. Brand presets override SEO presets for colors, mood, and typography
+4. SEO presets always provide aspect ratio and resolution defaults

package/.agent/skills/seo-image-gen/scripts/batch.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Claude Banana - CSV Batch Workflow
+
+Parse a CSV file of image generation requests and output a structured plan.
+Claude then executes each row via MCP.
+
+Usage:
+    batch.py --csv path/to/file.csv
+
+CSV columns:
+    prompt (required), ratio, resolution, model, preset (all optional)
+
+Example CSV:
+    prompt,ratio,resolution
+    "coffee shop hero image",16:9,2K
+    "team photo placeholder",1:1,1K
+    "product shot on marble",4:3,2K
+"""
+
+import argparse
+import csv
+import json
+import sys
+from pathlib import Path
+
+# Inline pricing for estimates
+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},
+}
+DEFAULT_MODEL = "gemini-3.1-flash-image-preview"
+DEFAULT_RESOLUTION = "1K"
+DEFAULT_RATIO = "1:1"
+
+
+def estimate_cost(model, resolution):
+    """Estimate cost for a single image."""
+    model_pricing = PRICING.get(model, PRICING[DEFAULT_MODEL])
+    return model_pricing.get(resolution, model_pricing.get("1K", 0.039))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Parse CSV batch and output generation plan")
+    parser.add_argument("--csv", required=True, help="Path to CSV file")
+    args = parser.parse_args()
+
+    csv_path = Path(args.csv).resolve()
+    if not csv_path.exists():
+        print(json.dumps({"error": True, "message": f"CSV not found: {csv_path}"}))
+        sys.exit(1)
+
+    rows = []
+    errors = []
+
+    try:
+        with open(csv_path, "r", newline="") as f:
+            reader = csv.DictReader(f)
+            if not reader.fieldnames or "prompt" not in reader.fieldnames:
+                print(json.dumps({"error": True, "message": "CSV must have a 'prompt' column header"}))
+                sys.exit(1)
+            for i, row in enumerate(reader, start=2):  # Line 2+ (1 is header)
+                prompt = row.get("prompt", "").strip()
+                if not prompt:
+                    errors.append(f"Row {i}: missing prompt")
+                    continue
+
+                rows.append({
+                    "row": i,
+                    "prompt": prompt,
+                    "ratio": row.get("ratio", "").strip() or DEFAULT_RATIO,
+                    "resolution": row.get("resolution", "").strip() or DEFAULT_RESOLUTION,
+                    "model": row.get("model", "").strip() or DEFAULT_MODEL,
+                    "preset": row.get("preset", "").strip() or None,
+                })
+    except (csv.Error, UnicodeDecodeError) as e:
+        print(json.dumps({"error": True, "message": f"Failed to parse CSV: {e}"}))
+        sys.exit(1)
+
+    if errors:
+        print("Validation errors:")
+        for e in errors:
+            print(f"  - {e}")
+        if not rows:
+            sys.exit(1)
+        print()
+
+    # Cost estimate
+    total_cost = sum(estimate_cost(r["model"], r["resolution"]) for r in rows)
+
+    # Output structured JSON for Claude to consume
+    print(json.dumps({"rows": rows, "total_count": len(rows),
+                       "estimated_cost": round(total_cost, 3),
+                       "errors": errors}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/.agent/skills/seo-image-gen/scripts/cost_tracker.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""Claude Banana - 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="Claude Banana 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/.agent/skills/seo-image-gen/scripts/edit.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""Claude Banana - 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 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",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=120) as resp:
+            result = json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        error_body = e.read().decode("utf-8") if e.fp else ""
+        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)
+
+    # 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()