renolation/english
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
renolation
2026-04-12 01:06:31 +07:00
commit 10d660cbcb
1066 changed files with 228596 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

484
.opencode/skills/design/scripts/cip/generate.py Normal file
View File

@@ -0,0 +1,484 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
CIP Design Generator - Generate corporate identity mockups using Gemini Nano Banana
Uses Gemini's native image generation (Nano Banana 2/Pro) for high-quality mockups.
Supports text-and-image-to-image generation for using actual brand logos.
- gemini-3.1-flash-image-preview: Nano Banana 2, fastest, 95% Pro quality (default)
- gemini-3-pro-image-preview: Pro quality, 4K text rendering
Image Editing (text-and-image-to-image):
When --logo is provided, the script uses Gemini's image editing capability
to incorporate the actual logo into CIP mockups instead of generating one.
"""
import argparse
import json
import os
import sys
from pathlib import Path
from datetime import datetime
# Add parent directory for imports
sys.path.insert(0, str(Path(__file__).parent))
from core import search, get_cip_brief
# Model options
MODELS = {
"flash": "gemini-3.1-flash-image-preview", # Nano Banana 2 - fastest, 95% Pro quality (default)
"pro": "gemini-3-pro-image-preview" # Nano Banana Pro - quality, 4K text
}
DEFAULT_MODEL = "flash"
def load_logo_image(logo_path):
"""Load logo image using PIL for Gemini image editing"""
try:
from PIL import Image
except ImportError:
print("Error: pillow package not installed.")
print("Install with: pip install pillow")
return None
logo_path = Path(logo_path)
if not logo_path.exists():
print(f"Error: Logo file not found: {logo_path}")
return None
try:
img = Image.open(logo_path)
# Convert to RGB if necessary (Gemini works best with RGB)
if img.mode in ('RGBA', 'P'):
# Create white background for transparent images
background = Image.new('RGB', img.size, (255, 255, 255))
if img.mode == 'RGBA':
background.paste(img, mask=img.split()[3]) # Use alpha channel as mask
else:
background.paste(img)
img = background
elif img.mode != 'RGB':
img = img.convert('RGB')
return img
except Exception as e:
print(f"Error loading logo: {e}")
return None
# Load environment variables
def load_env():
"""Load environment variables from .env files"""
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()
def build_cip_prompt(deliverable, brand_name, style=None, industry=None, mockup=None, use_logo_image=False):
"""Build an optimized prompt for CIP mockup generation
Args:
deliverable: Type of deliverable (business card, letterhead, etc.)
brand_name: Name of the brand
style: Design style preference
industry: Industry for style recommendations
mockup: Mockup context override
use_logo_image: If True, prompt is optimized for image editing with logo
"""
# Get deliverable details
deliverable_info = search(deliverable, "deliverable", 1)
deliverable_data = deliverable_info.get("results", [{}])[0] if deliverable_info.get("results") else {}
# Get style details
style_info = search(style or "corporate minimal", "style", 1) if style else {}
style_data = style_info.get("results", [{}])[0] if style_info.get("results") else {}
# Get industry details
industry_info = search(industry or "technology", "industry", 1) if industry else {}
industry_data = industry_info.get("results", [{}])[0] if industry_info.get("results") else {}
# Get mockup context
mockup_context = deliverable_data.get("Mockup Context", "clean professional")
if mockup:
mockup_info = search(mockup, "mockup", 1)
if mockup_info.get("results"):
mockup_data = mockup_info["results"][0]
mockup_context = mockup_data.get("Scene Description", mockup_context)
# Build prompt components
deliverable_name = deliverable_data.get("Deliverable", deliverable)
description = deliverable_data.get("Description", "")
dimensions = deliverable_data.get("Dimensions", "")
logo_placement = deliverable_data.get("Logo Placement", "center")
style_name = style_data.get("Style Name", style or "corporate")
primary_colors = style_data.get("Primary Colors", industry_data.get("Primary Colors", "#0F172A #FFFFFF"))
typography = style_data.get("Typography", industry_data.get("Typography", "clean sans-serif"))
materials = style_data.get("Materials", "premium quality")
finishes = style_data.get("Finishes", "professional")
mood = style_data.get("Mood", industry_data.get("Mood", "professional"))
# Construct the prompt - different for image editing vs pure generation
if use_logo_image:
# Image editing prompt: instructs to USE the provided logo image
prompt_parts = [
f"Create a professional corporate identity mockup photograph of a {deliverable_name}",
f"Use the EXACT logo from the provided image - do NOT modify or recreate the logo",
f"The logo MUST appear exactly as shown in the input image",
f"Place the logo on the {deliverable_name} at: {logo_placement}",
f"Brand name: '{brand_name}'",
f"{description}" if description else "",
f"Design style: {style_name}",
f"Color scheme matching the logo colors",
f"Materials: {materials} with {finishes} finish",
f"Setting: {mockup_context}",
f"Mood: {mood}",
"Photorealistic product photography",
"Soft natural lighting, professional studio quality",
"8K resolution, sharp details"
]
else:
# Pure text-to-image prompt
prompt_parts = [
f"Professional corporate identity mockup photograph",
f"showing {deliverable_name} for brand '{brand_name}'",
f"{description}" if description else "",
f"{style_name} design style",
f"using colors {primary_colors}",
f"{typography} typography",
f"logo placement: {logo_placement}",
f"{materials} materials with {finishes} finish",
f"{mockup_context} setting",
f"{mood} mood",
"photorealistic product photography",
"soft natural lighting",
"high quality professional shot",
"8k resolution detailed"
]
prompt = ", ".join([p for p in prompt_parts if p])
return {
"prompt": prompt,
"deliverable": deliverable_name,
"style": style_name,
"brand": brand_name,
"colors": primary_colors,
"mockup_context": mockup_context,
"logo_placement": logo_placement
}
def generate_with_nano_banana(prompt_data, output_dir=None, model_key="flash", aspect_ratio="1:1", logo_image=None):
"""Generate image using Gemini Nano Banana (native image generation)
Supports two modes:
1. Text-to-image: Pure prompt-based generation (logo_image=None)
2. Image editing: Text-and-image-to-image using provided logo (logo_image=PIL.Image)
Models:
- flash: gemini-3.1-flash-image-preview (fast, cost-effective) - DEFAULT
- pro: gemini-3-pro-image-preview (quality, 4K text rendering)
Args:
prompt_data: Dict with prompt, deliverable, brand, etc.
output_dir: Output directory for generated images
model_key: 'flash' or 'pro'
aspect_ratio: Output aspect ratio (1:1, 16:9, etc.)
logo_image: PIL.Image object of the brand logo for image editing mode
"""
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")
return None
api_key = os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY")
if not api_key:
print("Error: GEMINI_API_KEY or GOOGLE_API_KEY not set")
return None
client = genai.Client(api_key=api_key)
prompt = prompt_data["prompt"]
model_name = MODELS.get(model_key, MODELS[DEFAULT_MODEL])
# Determine mode
mode = "image-editing" if logo_image else "text-to-image"
print(f"\n🎨 Generating CIP mockup...")
print(f" Mode: {mode}")
print(f" Deliverable: {prompt_data['deliverable']}")
print(f" Brand: {prompt_data['brand']}")
print(f" Style: {prompt_data['style']}")
print(f" Model: {model_name}")
print(f" Context: {prompt_data['mockup_context']}")
if logo_image:
print(f" Logo: Using provided image ({logo_image.size[0]}x{logo_image.size[1]})")
try:
# Build contents: either just prompt or [prompt, image] for image editing
if logo_image:
# Image editing mode: pass both prompt and logo image
contents = [prompt, logo_image]
else:
# Text-to-image mode: just the prompt
contents = prompt
# Use generate_content with response_modalities=['IMAGE'] for Nano Banana
response = client.models.generate_content(
model=model_name,
contents=contents,
config=types.GenerateContentConfig(
response_modalities=['IMAGE'], # Uppercase required
image_config=types.ImageConfig(
aspect_ratio=aspect_ratio
)
)
)
# Extract image from response
if response.candidates and response.candidates[0].content.parts:
for part in response.candidates[0].content.parts:
if hasattr(part, 'inline_data') and part.inline_data:
# Save image
output_dir = output_dir or Path.cwd()
output_dir = Path(output_dir)
output_dir.mkdir(parents=True, exist_ok=True)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
brand_slug = prompt_data["brand"].lower().replace(" ", "-")
deliverable_slug = prompt_data["deliverable"].lower().replace(" ", "-")
filename = f"{brand_slug}-{deliverable_slug}-{timestamp}.png"
filepath = output_dir / filename
image_data = part.inline_data.data
with open(filepath, "wb") as f:
f.write(image_data)
print(f"\n✅ Generated: {filepath}")
return str(filepath)
print("No image generated in response")
return None
except Exception as e:
print(f"Error generating image: {e}")
return None
def generate_cip_set(brand_name, industry, style=None, deliverables=None, output_dir=None, model_key="flash", logo_path=None, aspect_ratio="1:1"):
"""Generate a complete CIP set for a brand
Args:
brand_name: Brand name to generate for
industry: Industry type for style recommendations
style: Optional specific style override
deliverables: List of deliverables to generate (default: core set)
output_dir: Output directory for images
model_key: 'flash' (fast) or 'pro' (quality)
logo_path: Path to brand logo image for image editing mode
aspect_ratio: Output aspect ratio
"""
# Load logo image if provided
logo_image = None
if logo_path:
logo_image = load_logo_image(logo_path)
if not logo_image:
print("Warning: Could not load logo, falling back to text-to-image mode")
# Get CIP brief for the brand
brief = get_cip_brief(brand_name, industry, style)
# Default deliverables if not specified
if not deliverables:
deliverables = ["business card", "letterhead", "office signage", "vehicle", "polo shirt"]
results = []
for deliverable in deliverables:
prompt_data = build_cip_prompt(
deliverable=deliverable,
brand_name=brand_name,
style=brief.get("style", {}).get("Style Name"),
industry=industry,
use_logo_image=(logo_image is not None)
)
filepath = generate_with_nano_banana(
prompt_data,
output_dir,
model_key=model_key,
aspect_ratio=aspect_ratio,
logo_image=logo_image
)
if filepath:
results.append({
"deliverable": deliverable,
"filepath": filepath,
"prompt": prompt_data["prompt"]
})
return results
def check_logo_required(brand_name, skip_prompt=False):
"""Check if logo is required and suggest logo-design skill if not provided
Returns:
str: 'continue' to proceed without logo, 'generate' to use logo-design skill, 'exit' to abort
"""
if skip_prompt:
return 'continue'
print(f"\n⚠️ No logo image provided for '{brand_name}'")
print(" Without a logo, AI will generate its own interpretation of the brand logo.")
print("")
print(" Options:")
print(" 1. Continue without logo (AI-generated logo interpretation)")
print(" 2. Generate a logo first using 'logo-design' skill")
print(" 3. Exit and provide a logo path with --logo")
print("")
try:
choice = input(" Enter choice [1/2/3] (default: 1): ").strip()
if choice == '2':
return 'generate'
elif choice == '3':
return 'exit'
return 'continue'
except (EOFError, KeyboardInterrupt):
return 'continue'
def main():
parser = argparse.ArgumentParser(
description="Generate CIP mockups using Gemini Nano Banana",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
# Generate with brand logo (RECOMMENDED)
python generate.py --brand "TopGroup" --logo /path/to/logo.png --deliverable "business card"
# Generate CIP set with logo
python generate.py --brand "TopGroup" --logo /path/to/logo.png --industry "consulting" --set
# Generate without logo (AI interprets brand)
python generate.py --brand "TechFlow" --deliverable "business card" --no-logo-prompt
# Generate with Pro model (higher quality, 4K text)
python generate.py --brand "TechFlow" --logo logo.png --deliverable "business card" --model pro
# Specify output directory and aspect ratio
python generate.py --brand "MyBrand" --logo logo.png --deliverable "vehicle" --output ./mockups --ratio 16:9
Models:
flash (default): gemini-3.1-flash-image-preview - Fast, cost-effective
pro: gemini-3-pro-image-preview - Quality, 4K text rendering
Image Editing Mode:
When --logo is provided, uses Gemini's text-and-image-to-image capability
to incorporate your ACTUAL logo into the CIP mockups.
"""
)
parser.add_argument("--brand", "-b", required=True, help="Brand name")
parser.add_argument("--logo", "-l", help="Path to brand logo image (enables image editing mode)")
parser.add_argument("--deliverable", "-d", help="Single deliverable to generate")
parser.add_argument("--deliverables", help="Comma-separated list of deliverables")
parser.add_argument("--industry", "-i", default="technology", help="Industry type")
parser.add_argument("--style", "-s", help="Design style")
parser.add_argument("--mockup", "-m", help="Mockup context")
parser.add_argument("--set", action="store_true", help="Generate full CIP set")
parser.add_argument("--output", "-o", help="Output directory")
parser.add_argument("--model", default="flash", choices=["flash", "pro"], help="Model: flash (fast) or pro (quality)")
parser.add_argument("--ratio", default="1:1", help="Aspect ratio (1:1, 16:9, 4:3, etc.)")
parser.add_argument("--prompt-only", action="store_true", help="Only show prompt, don't generate")
parser.add_argument("--json", "-j", action="store_true", help="Output as JSON")
parser.add_argument("--no-logo-prompt", action="store_true", help="Skip logo prompt, proceed without logo")
args = parser.parse_args()
# Check if logo is provided, prompt user if not
logo_image = None
if args.logo:
logo_image = load_logo_image(args.logo)
if not logo_image:
print("Error: Could not load logo image")
sys.exit(1)
elif not args.prompt_only:
# No logo provided - ask user what to do
action = check_logo_required(args.brand, skip_prompt=args.no_logo_prompt)
if action == 'generate':
print("\n💡 To generate a logo, use the logo-design skill:")
print(f" python ~/.opencode/skills/design/scripts/logo/generate.py --brand \"{args.brand}\" --industry \"{args.industry}\"")
print("\n Then re-run this command with --logo <generated_logo.png>")
sys.exit(0)
elif action == 'exit':
print("\n Provide logo with: --logo /path/to/your/logo.png")
sys.exit(0)
# else: continue without logo
use_logo = logo_image is not None
if args.set or args.deliverables:
# Generate multiple deliverables
deliverables = args.deliverables.split(",") if args.deliverables else None
if args.prompt_only:
results = []
deliverables = deliverables or ["business card", "letterhead", "office signage", "vehicle", "polo shirt"]
for d in deliverables:
prompt_data = build_cip_prompt(d, args.brand, args.style, args.industry, args.mockup, use_logo_image=use_logo)
results.append(prompt_data)
if args.json:
print(json.dumps(results, indent=2))
else:
for r in results:
print(f"\n{r['deliverable']}:\n{r['prompt']}\n")
else:
results = generate_cip_set(
args.brand, args.industry, args.style, deliverables, args.output,
model_key=args.model, logo_path=args.logo, aspect_ratio=args.ratio
)
if args.json:
print(json.dumps(results, indent=2))
else:
print(f"\n✅ Generated {len(results)} CIP mockups")
else:
# Generate single deliverable
deliverable = args.deliverable or "business card"
prompt_data = build_cip_prompt(deliverable, args.brand, args.style, args.industry, args.mockup, use_logo_image=use_logo)
if args.prompt_only:
if args.json:
print(json.dumps(prompt_data, indent=2))
else:
print(f"\nPrompt:\n{prompt_data['prompt']}")
else:
filepath = generate_with_nano_banana(
prompt_data, args.output, model_key=args.model,
aspect_ratio=args.ratio, logo_image=logo_image
)
if args.json:
print(json.dumps({"filepath": filepath, **prompt_data}, indent=2))
if __name__ == "__main__":
main()