Merge pull request #15 from ComfyAssets/chore/housekeeping

Chore/housekeeping

example.py

@@ -226,9 +226,11 @@ class HFHubLoraLoader:
 
         lora_path = hf_hub_download(
             repo_id=repo_id.strip(),
-            subfolder=None
-            if subfolder is None or subfolder.strip() == ""
-            else subfolder.strip(),
+            subfolder=(
+                None
+                if subfolder is None or subfolder.strip() == ""
+                else subfolder.strip()
+            ),
             filename=filename.strip(),
             cache_dir=find_or_create_cache(),
         )
@@ -281,9 +283,11 @@ class HFHubEmbeddingLoader:
     ):
         hf_hub_download(
             repo_id=repo_id.strip(),
-            subfolder=None
-            if subfolder is None or subfolder.strip() == ""
-            else subfolder.strip(),
+            subfolder=(
+                None
+                if subfolder is None or subfolder.strip() == ""
+                else subfolder.strip()
+            ),
             filename=filename.strip(),
             local_dir=get_folder_paths("embeddings")[0],
         )

examples/documentation/gemini_prompt.md

@@ -0,0 +1,162 @@
+# Gemini Prompt Engineer
+
+The Gemini Prompt Engineer node uses Google's Gemini AI to analyze images and generate optimized prompts for various AI image generation models.
+
+## Features
+
+- **Multi-Model Support**: Generate prompts optimized for FLUX, SDXL, Danbooru, and Video generation
+- **Custom Prompts**: Override templates with your own system prompts
+- **Visual Feedback**: UI shows processing status and error states
+- **Flexible API Key Management**: Multiple ways to provide API credentials
+
+## Setup
+
+### 1. Get API Key
+
+Get your free Gemini API key from [Google AI Studio](https://makersuite.google.com/app/apikey)
+
+### 2. Install Dependencies
+
+```bash
+pip install google-generativeai
+```
+
+### 3. Configure API Key
+
+Choose one of these methods:
+
+1. **Environment Variable** (Recommended):
+   ```bash
+   export GEMINI_API_KEY="your-api-key-here"
+   ```
+
+2. **Config File**:
+   Create `gemini_config.json` in your ComfyUI root directory:
+   ```json
+   {
+     "api_key": "your-api-key-here"
+   }
+   ```
+
+3. **Node Input**:
+   Enter the API key directly in the node's `api_key` field
+
+## Inputs
+
+- **image** (IMAGE): The image to analyze
+- **prompt_type** (DROPDOWN): Type of prompt to generate
+  - `flux`: Detailed artistic prompts with quality markers
+  - `sdxl`: Positive/negative prompt pairs with weight emphasis
+  - `danbooru`: Anime-style booru tags with underscores
+  - `video`: Motion and temporal descriptions for video generation
+- **api_key** (STRING, optional): Gemini API key if not set elsewhere
+- **custom_prompt** (STRING, optional): Override template with custom system prompt
+
+## Outputs
+
+- **prompt** (STRING): Generated prompt text
+- **negative_prompt** (STRING): Negative prompt (only populated for SDXL format)
+
+## Prompt Type Details
+
+### FLUX Format
+Generates detailed prompts optimized for FLUX models:
+- Starts with main subject and action
+- Includes style and medium descriptors
+- Adds lighting and atmosphere details
+- Uses quality markers like "4K", "highly detailed", "award-winning"
+
+Example output:
+```
+majestic mountain landscape at golden hour, oil painting style, dramatic lighting with sun rays piercing through clouds, wide angle composition, warm color palette with orange and purple hues, highly detailed, 4K resolution, trending on ArtStation, photorealistic rendering
+```
+
+### SDXL Format
+Generates positive and negative prompt pairs:
+- Detailed positive prompts with weight emphasis
+- Comprehensive negative prompts to avoid common issues
+- Uses parentheses for emphasis: `(detailed eyes:1.2)`
+
+Example output:
+```
+Positive: beautiful woman, (detailed eyes:1.2), flowing red dress, golden hour lighting, professional photography, 85mm lens, shallow depth of field, bokeh, high resolution, masterpiece
+Negative: low quality, blurry, distorted features, bad anatomy, poorly drawn, amateur, oversaturated, jpeg artifacts
+```
+
+### Danbooru Format
+Generates booru-style tags for anime artwork:
+- Uses underscores for multi-word concepts
+- Includes character count descriptors (1girl, 2boys)
+- Orders tags from most to least important
+
+Example output:
+```
+1girl, solo, long_hair, blue_eyes, blonde_hair, school_uniform, serafuku, pleated_skirt, thighhighs, smile, looking_at_viewer, classroom, sitting, desk, window, sunlight, highres, masterpiece
+```
+
+### Video Format
+Generates prompts for video generation models:
+- Describes motion and camera movements
+- Includes temporal markers and transitions
+- Specifies technical details like fps and duration
+
+Example output:
+```
+Aerial shot slowly descending toward a misty forest at dawn, camera smoothly transitions to tracking shot following a deer through the trees, photorealistic style, soft golden hour lighting with fog, 10 second duration, 4K resolution 24fps, ending with close-up of deer looking at camera
+```
+
+## Custom System Prompts
+
+You can override any template by providing your own system prompt. This is useful for:
+- Specialized use cases
+- Different language outputs
+- Custom formatting requirements
+- Integration with specific workflows
+
+Example custom prompt:
+```
+You are an expert at analyzing images and creating simple, concise descriptions.
+Focus only on the main subject and primary colors.
+Keep your response under 50 words.
+```
+
+## Error Handling
+
+The node provides clear error messages for common issues:
+- Missing API key
+- API request failures
+- Invalid image inputs
+- Rate limiting
+
+Errors are displayed in the prompt output for easy debugging.
+
+## Tips
+
+1. **API Usage**: Gemini has generous free tier limits, but be mindful of rate limits
+2. **Image Quality**: Higher resolution images provide better analysis results
+3. **Prompt Refinement**: You can chain multiple Gemini nodes with different custom prompts
+4. **Caching**: Results are not cached, so identical images will make new API calls
+
+## Example Workflow
+
+1. Load an image using Load Image node
+2. Connect to Gemini Prompt Engineer
+3. Select appropriate prompt_type for your target model
+4. Connect prompt output to your generation model
+5. For SDXL, connect both prompt and negative_prompt outputs
+
+## Troubleshooting
+
+**"API key not found" error**:
+- Check environment variable is set correctly
+- Verify config file path and JSON format
+- Try entering key directly in node
+
+**"No response generated" error**:
+- Check internet connection
+- Verify API key is valid
+- Image might be too large (resize if needed)
+
+**Import error for google-generativeai**:
+- Run `pip install google-generativeai` in your ComfyUI environment
+- Restart ComfyUI after installation

kikotools/__init__.py

@@ -10,6 +10,7 @@ from .tools.sampler_combo import SamplerComboNode, SamplerComboCompactNode
 from .tools.empty_latent_batch import EmptyLatentBatchNode
 from .tools.kiko_save_image import KikoSaveImageNode
 from .tools.image_to_multiple_of import ImageToMultipleOfNode
+from .tools.gemini_prompt import GeminiPromptNode
 
 # ComfyUI node registration mappings
 NODE_CLASS_MAPPINGS = {
@@ -21,6 +22,7 @@ NODE_CLASS_MAPPINGS = {
     "EmptyLatentBatch": EmptyLatentBatchNode,
     "KikoSaveImage": KikoSaveImageNode,
     "ImageToMultipleOf": ImageToMultipleOfNode,
+    "GeminiPrompt": GeminiPromptNode,
 }
 
 NODE_DISPLAY_NAME_MAPPINGS = {
@@ -32,6 +34,7 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "EmptyLatentBatch": "Empty Latent Batch",
     "KikoSaveImage": "Kiko Save Image",
     "ImageToMultipleOf": "Image to Multiple of",
+    "GeminiPrompt": "Gemini Prompt Engineer",
 }
 
 __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

kikotools/base/base_node.py

@@ -35,7 +35,9 @@ class ComfyAssetsBaseNode:
         """
         pass
 
-    def handle_error(self, error_msg: str, exception: Optional[Exception] = None) -> None:
+    def handle_error(
+        self, error_msg: str, exception: Optional[Exception] = None
+    ) -> None:
         """
         Standardized error handling with logging
 

kikotools/tools/empty_latent_batch/logic.py

@@ -4,7 +4,9 @@ import torch
 from typing import Dict, Tuple
 
 
-def create_empty_latent_batch(width: int, height: int, batch_size: int = 1) -> Dict[str, torch.Tensor]:
+def create_empty_latent_batch(
+    width: int, height: int, batch_size: int = 1
+) -> Dict[str, torch.Tensor]:
     """
     Create empty latent tensor with batch support.
 
@@ -28,7 +30,9 @@ def create_empty_latent_batch(width: int, height: int, batch_size: int = 1) -> D
 
     # Ensure dimensions are divisible by 8 (VAE requirement)
     if width % 8 != 0 or height % 8 != 0:
-        raise ValueError(f"Width and height must be divisible by 8, got {width}x{height}")
+        raise ValueError(
+            f"Width and height must be divisible by 8, got {width}x{height}"
+        )
 
     # Convert pixel dimensions to latent space (divide by 8)
     latent_width = width // 8

kikotools/tools/empty_latent_batch/node.py

@@ -36,7 +36,8 @@ class EmptyLatentBatchNode(ComfyAssetsBaseNode):
                 metadata = PRESET_METADATA.get(preset_name)
                 if metadata:
                     formatted_option = (
-                        f"{preset_name} - {metadata.aspect_ratio} " f"({metadata.megapixels:.1f}MP) - {metadata.model_group}"
+                        f"{preset_name} - {metadata.aspect_ratio} "
+                        f"({metadata.megapixels:.1f}MP) - {metadata.model_group}"
                     )
                     preset_options.append(formatted_option)
                 else:
@@ -85,7 +86,8 @@ class EmptyLatentBatchNode(ComfyAssetsBaseNode):
                         "min": 1,
                         "max": 64,
                         "step": 1,
-                        "tooltip": "Number of empty latents to create in the batch. " "Useful for batch processing workflows.",
+                        "tooltip": "Number of empty latents to create in the batch. "
+                        "Useful for batch processing workflows.",
                     },
                 ),
             }
@@ -116,7 +118,9 @@ class EmptyLatentBatchNode(ComfyAssetsBaseNode):
             original_preset = self._extract_preset_name(preset)
 
             # Get base dimensions from preset or custom input
-            base_width, base_height = get_preset_dimensions(original_preset, width, height)
+            base_width, base_height = get_preset_dimensions(
+                original_preset, width, height
+            )
 
             # Sanitize dimensions to ensure they meet requirements
             final_width, final_height = sanitize_dimensions(base_width, base_height)
@@ -130,17 +134,23 @@ class EmptyLatentBatchNode(ComfyAssetsBaseNode):
 
             # Validate final dimensions
             if not validate_dimensions(final_width, final_height):
-                self.handle_error(f"Invalid dimensions after sanitization: {final_width}×{final_height}")
+                self.handle_error(
+                    f"Invalid dimensions after sanitization: {final_width}×{final_height}"
+                )
 
             # Validate batch size
             if batch_size <= 0:
                 self.handle_error(f"Batch size must be positive, got {batch_size}")
 
             if batch_size > 64:
-                self.log_info(f"Large batch size ({batch_size}) may use significant memory")
+                self.log_info(
+                    f"Large batch size ({batch_size}) may use significant memory"
+                )
 
             # Create the empty latent batch
-            latent_dict = create_empty_latent_batch(final_width, final_height, batch_size)
+            latent_dict = create_empty_latent_batch(
+                final_width, final_height, batch_size
+            )
 
             # Log the operation
             latent_height = final_height // 8
@@ -188,7 +198,9 @@ class EmptyLatentBatchNode(ComfyAssetsBaseNode):
         # Default to "custom" if we can't parse it
         return "custom"
 
-    def validate_inputs(self, preset: str, width: int, height: int, batch_size: int) -> bool:
+    def validate_inputs(
+        self, preset: str, width: int, height: int, batch_size: int
+    ) -> bool:
         """
         Validate node inputs.
 
@@ -279,7 +291,12 @@ class EmptyLatentBatchNode(ComfyAssetsBaseNode):
 
     def __repr__(self) -> str:
         """Detailed string representation of the node."""
-        return f"EmptyLatentBatchNode(" f"category='{self.CATEGORY}', " f"function='{self.FUNCTION}'" f")"
+        return (
+            f"EmptyLatentBatchNode("
+            f"category='{self.CATEGORY}', "
+            f"function='{self.FUNCTION}'"
+            f")"
+        )
 
 
 # Node class mappings for ComfyUI registration

kikotools/tools/gemini_prompt/__init__.py

@@ -0,0 +1,5 @@
+"""Gemini Prompt Engineer node for ComfyUI."""
+
+from .node import GeminiPromptNode
+
+__all__ = ["GeminiPromptNode"]

kikotools/tools/gemini_prompt/logic.py

@@ -0,0 +1,163 @@
+"""Logic for Gemini API integration and prompt generation."""
+
+import base64
+import io
+import json
+import os
+from typing import Optional, Tuple
+
+import numpy as np
+from PIL import Image
+
+from .prompts import PROMPT_TEMPLATES
+
+
+def tensor_to_pil(tensor: np.ndarray) -> Image.Image:
+    """Convert ComfyUI tensor to PIL Image.
+
+    Args:
+        tensor: Input tensor in ComfyUI format (B, H, W, C)
+
+    Returns:
+        PIL Image object
+    """
+    # ComfyUI tensors are in [0, 1] range
+    if tensor.ndim == 4:
+        # Take first image from batch
+        tensor = tensor[0]
+
+    # Convert to uint8
+    image_array = (tensor * 255).astype(np.uint8)
+
+    # Convert to PIL
+    return Image.fromarray(image_array, mode="RGB")
+
+
+def image_to_base64(image: Image.Image, format: str = "PNG") -> str:
+    """Convert PIL Image to base64 string.
+
+    Args:
+        image: PIL Image object
+        format: Image format (PNG or JPEG)
+
+    Returns:
+        Base64 encoded string
+    """
+    buffer = io.BytesIO()
+    image.save(buffer, format=format)
+    buffer.seek(0)
+    return base64.b64encode(buffer.read()).decode("utf-8")
+
+
+def get_api_key() -> Optional[str]:
+    """Get Gemini API key from environment or config.
+
+    Returns:
+        API key string or None if not found
+    """
+    # Check environment variable first
+    api_key = os.environ.get("GEMINI_API_KEY")
+
+    if not api_key:
+        # Check for config file in ComfyUI directory
+        try:
+            config_path = os.path.join(
+                os.path.dirname(__file__), "..", "..", "..", "gemini_config.json"
+            )
+            if os.path.exists(config_path):
+                with open(config_path, "r") as f:
+                    config = json.load(f)
+                    api_key = config.get("api_key")
+        except Exception:
+            pass
+
+    return api_key
+
+
+def analyze_image_with_gemini(
+    image: np.ndarray,
+    prompt_type: str,
+    api_key: Optional[str] = None,
+    custom_prompt: Optional[str] = None,
+    model_name: str = "gemini-1.5-flash",
+) -> Tuple[str, Optional[str]]:
+    """Analyze image using Gemini API and generate appropriate prompt.
+
+    Args:
+        image: Input image tensor
+        prompt_type: Type of prompt to generate (flux, sdxl, danbooru, video)
+        api_key: Gemini API key (optional, will try to get from env/config)
+        custom_prompt: Custom system prompt to use instead of templates
+        model_name: Gemini model to use (default: gemini-1.5-flash)
+
+    Returns:
+        Tuple of (generated_prompt, error_message)
+    """
+    # Get API key
+    if not api_key:
+        api_key = get_api_key()
+
+    if not api_key:
+        return (
+            "",
+            "Gemini API key not found. Please set GEMINI_API_KEY environment variable or provide it in the node.",
+        )
+
+    # Convert tensor to PIL image
+    try:
+        pil_image = tensor_to_pil(image)
+    except Exception as e:
+        return "", f"Failed to convert image: {str(e)}"
+
+    # Get system prompt
+    if custom_prompt:
+        system_prompt = custom_prompt
+    else:
+        system_prompt = PROMPT_TEMPLATES.get(prompt_type, PROMPT_TEMPLATES["flux"])
+
+    # Here we would normally make the API call to Gemini
+    # For now, we'll import the google-generativeai library
+    try:
+        import google.generativeai as genai
+    except ImportError:
+        return (
+            "",
+            "google-generativeai library not installed. Please run: pip install google-generativeai",
+        )
+
+    try:
+        # Configure Gemini
+        genai.configure(api_key=api_key)
+
+        # Create model
+        model = genai.GenerativeModel(model_name)
+
+        # Generate content
+        response = model.generate_content(
+            [
+                system_prompt,
+                pil_image,
+                "Analyze this image and generate an appropriate prompt according to the instructions.",
+            ]
+        )
+
+        # Extract text from response
+        if response.text:
+            return response.text.strip(), None
+        else:
+            return "", "No response generated from Gemini"
+
+    except Exception as e:
+        return "", f"Gemini API error: {str(e)}"
+
+
+def validate_prompt_type(prompt_type: str) -> bool:
+    """Validate if prompt type is supported.
+
+    Args:
+        prompt_type: Type of prompt to validate
+
+    Returns:
+        True if valid, False otherwise
+    """
+    return prompt_type in PROMPT_TEMPLATES

kikotools/tools/gemini_prompt/node.py

@@ -0,0 +1,115 @@
+"""Gemini Prompt Engineer node implementation."""
+
+import torch
+
+from ...base import ComfyAssetsBaseNode
+
+from .logic import analyze_image_with_gemini, validate_prompt_type
+from .prompts import PROMPT_OPTIONS, GEMINI_MODELS
+
+
+class GeminiPromptNode(ComfyAssetsBaseNode):
+    """Analyzes images using Gemini AI to generate optimized prompts for various AI models."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        """Define input types for the node."""
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "prompt_type": (PROMPT_OPTIONS, {"default": "flux"}),
+                "model": (GEMINI_MODELS, {"default": "gemini-1.5-flash"}),
+            },
+            "optional": {
+                "api_key": ("STRING", {"default": "", "multiline": False}),
+                "custom_prompt": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "multiline": True,
+                        "placeholder": "Optional: Enter custom system prompt instead of using templates",
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("STRING", "STRING")
+    RETURN_NAMES = ("prompt", "negative_prompt")
+    FUNCTION = "generate_prompt"
+    CATEGORY = "ComfyAssets"
+
+    DESCRIPTION = """
+Analyzes images using Google's Gemini AI to generate optimized prompts.
+
+Supports multiple prompt formats:
+- FLUX: Detailed artistic prompts with quality markers
+- SDXL: Positive/negative prompt pairs with weight emphasis
+- Danbooru: Anime-style booru tags with underscores
+- Video: Motion and temporal descriptions for video generation
+
+Requires Gemini API key (set GEMINI_API_KEY env var or provide in node).
+Install: pip install google-generativeai
+"""
+
+    def generate_prompt(self, image, prompt_type, model, api_key="", custom_prompt=""):
+        """Generate prompt from image using Gemini.
+
+        Args:
+            image: Input image tensor
+            prompt_type: Type of prompt to generate
+            model: Gemini model to use
+            api_key: Optional API key
+            custom_prompt: Optional custom system prompt
+
+        Returns:
+            Tuple of (prompt, negative_prompt)
+        """
+        # Validate prompt type
+        if not validate_prompt_type(prompt_type):
+            raise ValueError(f"Invalid prompt type: {prompt_type}")
+
+        # Convert torch tensor to numpy if needed
+        if isinstance(image, torch.Tensor):
+            image_np = image.cpu().numpy()
+        else:
+            image_np = image
+
+        # Analyze image with Gemini
+        prompt, error = analyze_image_with_gemini(
+            image_np,
+            prompt_type,
+            api_key=api_key or None,
+            custom_prompt=custom_prompt or None,
+            model_name=model,
+        )
+
+        if error:
+            # Return error as prompt for visibility
+            return (f"Error: {error}", "")
+
+        # Handle different prompt types
+        if prompt_type == "sdxl":
+            # SDXL returns positive and negative prompts
+            lines = prompt.split("\n")
+            positive_prompt = ""
+            negative_prompt = ""
+
+            for line in lines:
+                if line.startswith("Positive:"):
+                    positive_prompt = line.replace("Positive:", "").strip()
+                elif line.startswith("Negative:"):
+                    negative_prompt = line.replace("Negative:", "").strip()
+
+            # If format not found, assume entire response is positive prompt
+            if not positive_prompt:
+                positive_prompt = prompt
+
+            return (positive_prompt, negative_prompt)
+
+        else:
+            # Other formats don't use negative prompts
+            return (prompt, "")
+
+
+# Node display name
+NODE_DISPLAY_NAME = "Gemini Prompt Engineer"

kikotools/tools/gemini_prompt/prompts.py

@@ -0,0 +1,200 @@
+"""System prompts for different AI model types."""
+
+FLUX_PROMPT = """You are an expert visual analyst and FLUX prompt engineer. Your role is to examine images in detail and create precise, effective prompts that can recreate similar images using the FLUX image generation model.
+
+When analyzing an image, systematically observe and document:
+
+1. **Subject & Composition**
+   - Primary subjects and their positions
+   - Background elements and environment
+   - Overall composition and framing
+   - Perspective and camera angle
+
+2. **Visual Style & Technique**
+   - Art style (photorealistic, illustration, painting, etc.)
+   - Rendering technique (digital art, oil painting, watercolor, etc.)
+   - Level of detail and texture quality
+   - Any specific artistic influences or movements
+
+3. **Lighting & Atmosphere**
+   - Light sources and direction
+   - Time of day/lighting conditions
+   - Shadows and highlights
+   - Overall mood and atmosphere
+
+4. **Colors & Tones**
+   - Color palette and dominant colors
+   - Color temperature (warm/cool)
+   - Contrast and saturation levels
+   - Any color grading or filters
+
+5. **Details & Textures**
+   - Surface textures and materials
+   - Fine details and patterns
+   - Quality indicators (4K, 8K, high resolution, etc.)
+
+Format your FLUX prompt following these guidelines:
+- Start with the main subject and action
+- Add style and medium descriptors
+- Include lighting and atmosphere details
+- Specify quality markers and technical aspects
+- Use precise, descriptive language
+- Separate concepts with commas
+- Order from most to least important elements
+
+Example output format:
+"[main subject and action], [style/medium], [lighting/atmosphere], [composition details], [color descriptions], [quality markers], [additional artistic details]"
+
+Remember: FLUX responds well to specific artistic references, quality indicators like "highly detailed," "4K," "award-winning," and style descriptors like "trending on ArtStation" or "photorealistic."
+"""
+
+SDXL_PROMPT = """You are an expert SDXL prompt engineer specializing in analyzing images and creating optimized prompts for Stable Diffusion XL models.
+
+When analyzing an image, systematically evaluate:
+
+1. **Core Subject Analysis**
+   - Primary subject with specific descriptors
+   - Pose, expression, and action
+   - Clothing and accessories details
+   - Physical characteristics
+
+2. **Style & Medium**
+   - Artistic style and influences
+   - Medium (photography, digital art, oil painting, etc.)
+   - Specific artist references (if applicable)
+   - Visual aesthetic keywords
+
+3. **Technical Specifications**
+   - Camera settings (aperture, focal length, ISO)
+   - Shot type (close-up, wide angle, portrait, etc.)
+   - Resolution and quality markers
+   - Post-processing effects
+
+4. **Environment & Context**
+   - Setting and location details
+   - Props and surrounding objects
+   - Weather and environmental conditions
+   - Time period or era
+
+Format your SDXL prompt with:
+- **Positive prompt**: Detailed description emphasizing what you want
+- **Negative prompt**: Elements to avoid (low quality, blurry, distorted, etc.)
+- Weight emphasis using (parentheses) or [brackets] for importance
+- Break into logical chunks with commas
+
+Example format:
+Positive: "beautiful woman, (detailed eyes:1.2), flowing red dress, golden hour lighting, professional photography, 85mm lens, shallow depth of field, bokeh, high resolution, masterpiece"
+Negative: "low quality, blurry, distorted features, bad anatomy, poorly drawn, amateur"
+"""
+
+DANBOORU_PROMPT = """You are a Danbooru tagging expert, specialized in analyzing images and creating precise tag sets following booru-style conventions for anime/manga artwork.
+
+Analyze images for these tag categories:
+
+1. **Character Tags**
+   - Hair: color, length, style (e.g., long_hair, blonde_hair, twintails)
+   - Eyes: color, style (e.g., blue_eyes, heterochromia)
+   - Body: proportions, pose (e.g., standing, sitting, looking_at_viewer)
+   - Expression (e.g., smile, blush, closed_eyes)
+
+2. **Clothing & Accessories**
+   - Outfit type (e.g., school_uniform, dress, armor)
+   - Specific clothing items (e.g., thighhighs, gloves, hat)
+   - Accessories (e.g., hair_ribbon, necklace, glasses)
+   - State of dress (e.g., torn_clothes, wet_clothes)
+
+3. **Scene & Composition**
+   - Number of characters (e.g., 1girl, 2boys, multiple_girls)
+   - Background (e.g., simple_background, outdoors, classroom)
+   - Viewpoint (e.g., from_below, from_side, cowboy_shot)
+   - Composition elements (e.g., upper_body, full_body, portrait)
+
+4. **Meta Tags**
+   - Quality (e.g., highres, absurdres, masterpiece)
+   - Source/artist style (if recognizable)
+   - Content rating (e.g., safe, questionable, explicit)
+   - Special effects (e.g., lens_flare, chromatic_aberration)
+
+Format tags using:
+- Underscores for multi-word concepts (not spaces)
+- Order from most to least important
+- Include count descriptors (1girl, 2boys)
+- Separate with commas and spaces
+
+Example output:
+"1girl, solo, long_hair, blue_eyes, blonde_hair, school_uniform, serafuku, pleated_skirt, thighhighs, smile, looking_at_viewer, classroom, sitting, desk, window, sunlight, highres, masterpiece"
+"""
+
+VIDEO_PROMPT = """You are a video generation prompt specialist, expert at analyzing video content and creating comprehensive prompts for video generation models.
+
+When analyzing video content, document:
+
+1. **Motion & Action**
+   - Primary actions and movements
+   - Motion speed and dynamics
+   - Camera movements (pan, zoom, tracking, static)
+   - Transition types between scenes
+
+2. **Temporal Elements**
+   - Scene duration and pacing
+   - Sequence of events
+   - Time of day changes
+   - Motion continuity
+
+3. **Visual Consistency**
+   - Character/object persistence
+   - Style consistency throughout
+   - Lighting continuity
+   - Color grading consistency
+
+4. **Scene Breakdown**
+   - Opening frame description
+   - Key action moments
+   - Transitions and cuts
+   - Closing frame details
+
+5. **Technical Specifications**
+   - Frame rate and resolution
+   - Aspect ratio
+   - Video length
+   - Special effects or post-processing
+
+Format your video prompt as:
+"[Opening scene], [camera movement], [main action sequence], [visual style], [lighting/atmosphere], [duration], [technical specs], [ending scene]"
+
+Include:
+- Specific motion descriptors (slowly, rapidly, smoothly)
+- Camera terminology (dolly in, pan left, aerial shot)
+- Temporal markers (then, meanwhile, gradually)
+- Consistency notes for multi-scene videos
+
+Example:
+"Aerial shot slowly descending toward a misty forest at dawn, camera smoothly transitions to tracking shot following a deer through the trees, photorealistic style, soft golden hour lighting with fog, 10 second duration, 4K resolution 24fps, ending with close-up of deer looking at camera"
+"""
+
+PROMPT_TEMPLATES = {
+    "flux": FLUX_PROMPT,
+    "sdxl": SDXL_PROMPT,
+    "danbooru": DANBOORU_PROMPT,
+    "video": VIDEO_PROMPT,
+}
+
+PROMPT_OPTIONS = ["flux", "sdxl", "danbooru", "video"]
+
+# Available Gemini models
+GEMINI_MODELS = [
+    "gemini-1.5-pro",  # Most capable model
+    "gemini-1.5-flash",  # Fast, efficient model
+    "gemini-1.5-flash-8b",  # Smaller, faster variant
+    "gemini-pro-vision",  # Vision-optimized model
+    "gemini-1.0-pro",  # Previous generation pro model
+]
+
+# Model descriptions for UI
+MODEL_DESCRIPTIONS = {
+    "gemini-1.5-pro": "Most capable Gemini model for complex tasks",
+    "gemini-1.5-flash": "Faster and cost-effective (recommended for most uses)",
+    "gemini-1.5-flash-8b": "Smaller and faster, good for simple prompts",
+    "gemini-pro-vision": "Optimized for vision tasks and image analysis",
+    "gemini-1.0-pro": "Previous generation, stable option",
+}

kikotools/tools/kiko_save_image/logic.py

@@ -48,7 +48,9 @@ def get_save_image_path(
     prefix_name = os.path.basename(filename_prefix)
 
     # Sanitize only the filename part (not the directory path)
-    safe_prefix = prefix_name.replace(":", "_")  # Only sanitize problematic chars for filenames
+    safe_prefix = prefix_name.replace(
+        ":", "_"
+    )  # Only sanitize problematic chars for filenames
     safe_prefix = "".join(c for c in safe_prefix if c.isalnum() or c in "._-")
 
     # Create unique filename with timestamp to avoid conflicts
@@ -114,7 +116,9 @@ def convert_tensor_to_pil(image_tensor: torch.Tensor) -> Image.Image:
     return img
 
 
-def create_png_metadata(prompt: Optional[Dict] = None, extra_pnginfo: Optional[Dict] = None) -> Optional[PngInfo]:
+def create_png_metadata(
+    prompt: Optional[Dict] = None, extra_pnginfo: Optional[Dict] = None
+) -> Optional[PngInfo]:
     """
     Create PNG metadata with workflow information
 
@@ -242,7 +246,10 @@ def process_image_batch(
     format_extensions = {"PNG": ".png", "JPEG": ".jpg", "WEBP": ".webp"}
 
     if format_type not in format_extensions:
-        raise ValueError(f"Unsupported format: {format_type}. " f"Supported: {list(format_extensions.keys())}")
+        raise ValueError(
+            f"Unsupported format: {format_type}. "
+            f"Supported: {list(format_extensions.keys())}"
+        )
 
     format_ext = format_extensions[format_type]
 
@@ -308,7 +315,9 @@ def process_image_batch(
     return results, enhanced_data
 
 
-def validate_save_inputs(images: torch.Tensor, format_type: str, quality: int, png_compress_level: int) -> None:
+def validate_save_inputs(
+    images: torch.Tensor, format_type: str, quality: int, png_compress_level: int
+) -> None:
     """
     Validate inputs for image saving
 
@@ -326,19 +335,31 @@ def validate_save_inputs(images: torch.Tensor, format_type: str, quality: int, p
         raise ValueError(f"images must be a torch.Tensor, got {type(images).__name__}")
 
     if len(images.shape) != 4:
-        raise ValueError(f"images tensor must have 4 dimensions [batch, height, width, channels], " f"got {len(images.shape)}")
+        raise ValueError(
+            f"images tensor must have 4 dimensions [batch, height, width, channels], "
+            f"got {len(images.shape)}"
+        )
 
     # Validate format
     supported_formats = ["PNG", "JPEG", "WEBP"]
     if format_type not in supported_formats:
-        raise ValueError(f"format must be one of {supported_formats}, got {format_type}")
+        raise ValueError(
+            f"format must be one of {supported_formats}, got {format_type}"
+        )
 
     # Validate quality (for JPEG/WebP)
     if format_type in ["JPEG", "WEBP"]:
         if not isinstance(quality, int) or not (1 <= quality <= 100):
-            raise ValueError(f"quality must be an integer between 1 and 100, got {quality}")
+            raise ValueError(
+                f"quality must be an integer between 1 and 100, got {quality}"
+            )
 
     # Validate PNG compression level
     if format_type == "PNG":
-        if not isinstance(png_compress_level, int) or not (0 <= png_compress_level <= 9):
-            raise ValueError(f"png_compress_level must be an integer between 0 and 9, " f"got {png_compress_level}")
+        if not isinstance(png_compress_level, int) or not (
+            0 <= png_compress_level <= 9
+        ):
+            raise ValueError(
+                f"png_compress_level must be an integer between 0 and 9, "
+                f"got {png_compress_level}"
+            )

kikotools/tools/kiko_save_image/node.py

@@ -79,7 +79,8 @@ class KikoSaveImageNode(ComfyAssetsBaseNode):
                     "BOOLEAN",
                     {
                         "default": False,
-                        "tooltip": "Use lossless WebP compression " "(ignores quality setting)",
+                        "tooltip": "Use lossless WebP compression "
+                        "(ignores quality setting)",
                     },
                 ),
                 "popup": (
@@ -162,7 +163,10 @@ class KikoSaveImageNode(ComfyAssetsBaseNode):
 
             # Log results
             total_size = sum(data["file_size"] for data in enhanced_data)
-            self.log_info(f"Successfully saved {len(results)} images " f"(total size: {total_size / 1024:.1f} KB)")
+            self.log_info(
+                f"Successfully saved {len(results)} images "
+                f"(total size: {total_size / 1024:.1f} KB)"
+            )
 
             # Return UI data for ComfyUI preview (clean) + enhanced data for our JS
             return {
@@ -204,7 +208,9 @@ class KikoSaveImageNode(ComfyAssetsBaseNode):
 
         # Additional node-specific validation
         if not isinstance(webp_lossless, bool):
-            raise ValueError(f"webp_lossless must be a boolean, got {type(webp_lossless).__name__}")
+            raise ValueError(
+                f"webp_lossless must be a boolean, got {type(webp_lossless).__name__}"
+            )
 
         if not isinstance(popup, bool):
             raise ValueError(f"popup must be a boolean, got {type(popup).__name__}")

kikotools/tools/resolution_calculator/logic.py

@@ -28,7 +28,9 @@ def extract_dimensions(
     if image is not None:
         # IMAGE tensor format: [batch, height, width, channels]
         if len(image.shape) != 4:
-            raise ValueError(f"Expected IMAGE tensor with 4 dimensions, got {len(image.shape)}")
+            raise ValueError(
+                f"Expected IMAGE tensor with 4 dimensions, got {len(image.shape)}"
+            )
 
         _, height, width, _ = image.shape
         return int(width), int(height)
@@ -40,7 +42,10 @@ def extract_dimensions(
 
         samples = latent["samples"]
         if len(samples.shape) != 4:
-            raise ValueError(f"Expected LATENT samples tensor with 4 dimensions, " f"got {len(samples.shape)}")
+            raise ValueError(
+                f"Expected LATENT samples tensor with 4 dimensions, "
+                f"got {len(samples.shape)}"
+            )
 
         _, _, latent_height, latent_width = samples.shape
 
@@ -74,7 +79,9 @@ def ensure_divisible_by_8(width: int, height: int) -> Tuple[int, int]:
     return int(new_width), int(new_height)
 
 
-def calculate_scaled_dimensions(width: int, height: int, scale_factor: float) -> Tuple[int, int]:
+def calculate_scaled_dimensions(
+    width: int, height: int, scale_factor: float
+) -> Tuple[int, int]:
     """
     Calculate new dimensions with scale factor and ensure divisible by 8
 
@@ -97,7 +104,9 @@ def calculate_scaled_dimensions(width: int, height: int, scale_factor: float) ->
     return ensure_divisible_by_8(new_width, new_height)
 
 
-def validate_scale_factor(scale_factor: float, min_scale: float = 0.1, max_scale: float = 8.0) -> None:
+def validate_scale_factor(
+    scale_factor: float, min_scale: float = 0.1, max_scale: float = 8.0
+) -> None:
     """
     Validate scale factor is within reasonable bounds
 
@@ -110,13 +119,19 @@ def validate_scale_factor(scale_factor: float, min_scale: float = 0.1, max_scale
         ValueError: If scale factor is out of bounds
     """
     if not isinstance(scale_factor, (int, float)):
-        raise ValueError(f"Scale factor must be a number, got {type(scale_factor).__name__}")
+        raise ValueError(
+            f"Scale factor must be a number, got {type(scale_factor).__name__}"
+        )
 
     if scale_factor < min_scale:
-        raise ValueError(f"Scale factor {scale_factor} is too small (minimum: {min_scale})")
+        raise ValueError(
+            f"Scale factor {scale_factor} is too small (minimum: {min_scale})"
+        )
 
     if scale_factor > max_scale:
-        raise ValueError(f"Scale factor {scale_factor} is too large (maximum: {max_scale})")
+        raise ValueError(
+            f"Scale factor {scale_factor} is too large (maximum: {max_scale})"
+        )
 
 
 def calculate_resolution_from_input(
@@ -146,6 +161,8 @@ def calculate_resolution_from_input(
     original_width, original_height = extract_dimensions(image=image, latent=latent)
 
     # Calculate scaled dimensions
-    new_width, new_height = calculate_scaled_dimensions(original_width, original_height, scale_factor)
+    new_width, new_height = calculate_scaled_dimensions(
+        original_width, original_height, scale_factor
+    )
 
     return new_width, new_height

kikotools/tools/resolution_calculator/node.py

@@ -42,7 +42,8 @@ class ResolutionCalculatorNode(ComfyAssetsBaseNode):
                         "max": 8.0,
                         "step": 0.1,
                         "display": "slider",
-                        "tooltip": "Factor to scale the resolution by " "(e.g., 2.0 for 2x, 0.5 for half scale)",
+                        "tooltip": "Factor to scale the resolution by "
+                        "(e.g., 2.0 for 2x, 0.5 for half scale)",
                     },
                 ),
             },
@@ -87,11 +88,20 @@ class ResolutionCalculatorNode(ComfyAssetsBaseNode):
             self.validate_inputs(scale_factor=scale_factor, image=image, latent=latent)
 
             # Log the operation
-            input_type = "IMAGE" if image is not None else "LATENT" if latent is not None else "NONE"
-            self.log_info(f"Calculating resolution with scale_factor={scale_factor}, " f"input_type={input_type}")
+            input_type = (
+                "IMAGE"
+                if image is not None
+                else "LATENT" if latent is not None else "NONE"
+            )
+            self.log_info(
+                f"Calculating resolution with scale_factor={scale_factor}, "
+                f"input_type={input_type}"
+            )
 
             # Calculate the resolution
-            width, height = calculate_resolution_from_input(scale_factor=scale_factor, image=image, latent=latent)
+            width, height = calculate_resolution_from_input(
+                scale_factor=scale_factor, image=image, latent=latent
+            )
 
             # Log the result
             self.log_info(f"Calculated resolution: {width}x{height}")
@@ -126,7 +136,9 @@ class ResolutionCalculatorNode(ComfyAssetsBaseNode):
 
         # Validate scale factor type
         if not isinstance(scale_factor, (int, float)):
-            raise ValueError(f"scale_factor must be a number, got {type(scale_factor).__name__}")
+            raise ValueError(
+                f"scale_factor must be a number, got {type(scale_factor).__name__}"
+            )
 
         # Validate tensors using helper methods
         if image is not None:
@@ -138,11 +150,14 @@ class ResolutionCalculatorNode(ComfyAssetsBaseNode):
     def _validate_image_tensor(self, image: torch.Tensor) -> None:
         """Validate image tensor format"""
         if not isinstance(image, torch.Tensor):
-            raise ValueError(f"image must be a torch.Tensor, got {type(image).__name__}")
+            raise ValueError(
+                f"image must be a torch.Tensor, got {type(image).__name__}"
+            )
 
         if len(image.shape) != 4:
             raise ValueError(
-                f"image tensor must have 4 dimensions " f"[batch, height, width, channels], got {len(image.shape)}"
+                f"image tensor must have 4 dimensions "
+                f"[batch, height, width, channels], got {len(image.shape)}"
             )
 
     def _validate_latent_dict(self, latent: Dict[str, torch.Tensor]) -> None:
@@ -155,11 +170,15 @@ class ResolutionCalculatorNode(ComfyAssetsBaseNode):
 
         samples = latent["samples"]
         if not isinstance(samples, torch.Tensor):
-            raise ValueError(f"latent['samples'] must be a torch.Tensor, " f"got {type(samples).__name__}")
+            raise ValueError(
+                f"latent['samples'] must be a torch.Tensor, "
+                f"got {type(samples).__name__}"
+            )
 
         if len(samples.shape) != 4:
             raise ValueError(
-                f"latent samples tensor must have 4 dimensions " f"[batch, channels, height, width], got {len(samples.shape)}"
+                f"latent samples tensor must have 4 dimensions "
+                f"[batch, channels, height, width], got {len(samples.shape)}"
             )
 
 

kikotools/tools/sampler_combo/compact_node.py

@@ -65,7 +65,9 @@ class SamplerComboCompactNode(ComfyAssetsBaseNode):
     FUNCTION = "get_combo"
     CATEGORY = "ComfyAssets"
 
-    def get_combo(self, sampler: str, sched: str, steps: int, cfg: float) -> Tuple[object, str, int, float]:
+    def get_combo(
+        self, sampler: str, sched: str, steps: int, cfg: float
+    ) -> Tuple[object, str, int, float]:
         """
         Get compact sampler combo configuration.
 

kikotools/tools/sampler_combo/logic.py

@@ -40,7 +40,9 @@ except ImportError:
     ]
 
 
-def validate_sampler_settings(sampler_name: str, scheduler: str, steps: int, cfg: float) -> bool:
+def validate_sampler_settings(
+    sampler_name: str, scheduler: str, steps: int, cfg: float
+) -> bool:
     """
     Validate sampler configuration settings.
 
@@ -81,7 +83,9 @@ def validate_sampler_settings(sampler_name: str, scheduler: str, steps: int, cfg
         return False
 
 
-def get_sampler_combo(sampler_name: str, scheduler: str, steps: int, cfg: float) -> Tuple[str, str, int, float]:
+def get_sampler_combo(
+    sampler_name: str, scheduler: str, steps: int, cfg: float
+) -> Tuple[str, str, int, float]:
     """
     Process and return sampler combo settings.
 

kikotools/tools/sampler_combo/node.py

@@ -70,7 +70,9 @@ class SamplerComboNode(ComfyAssetsBaseNode):
     FUNCTION = "get_sampler_combo"
     CATEGORY = "ComfyAssets"
 
-    def get_sampler_combo(self, sampler_name: str, scheduler: str, steps: int, cfg: float) -> Tuple[object, str, int, float]:
+    def get_sampler_combo(
+        self, sampler_name: str, scheduler: str, steps: int, cfg: float
+    ) -> Tuple[object, str, int, float]:
         """
         Get sampler combo configuration.
 
@@ -117,7 +119,10 @@ class SamplerComboNode(ComfyAssetsBaseNode):
                 # Return sampler name for testing
                 sampler = result[0]
 
-            self.log_info(f"Configured sampler combo: {result[0]}, {result[1]}, " f"{result[2]} steps, CFG {result[3]}")
+            self.log_info(
+                f"Configured sampler combo: {result[0]}, {result[1]}, "
+                f"{result[2]} steps, CFG {result[3]}"
+            )
 
             return (sampler, result[1], result[2], result[3])
 
@@ -139,7 +144,9 @@ class SamplerComboNode(ComfyAssetsBaseNode):
                 sampler = "euler"
             return (sampler, "normal", 20, 7.0)
 
-    def validate_inputs(self, sampler_name: str, scheduler: str, steps: int, cfg: float) -> None:
+    def validate_inputs(
+        self, sampler_name: str, scheduler: str, steps: int, cfg: float
+    ) -> None:
         """
         Validate sampler combo inputs.
 
@@ -154,7 +161,8 @@ class SamplerComboNode(ComfyAssetsBaseNode):
         """
         if not validate_sampler_settings(sampler_name, scheduler, steps, cfg):
             self.handle_error(
-                f"Invalid sampler settings: sampler={sampler_name}, " f"scheduler={scheduler}, steps={steps}, cfg={cfg}"
+                f"Invalid sampler settings: sampler={sampler_name}, "
+                f"scheduler={scheduler}, steps={steps}, cfg={cfg}"
             )
 
     def get_scheduler_suggestions(self, sampler_name: str) -> list:
@@ -205,7 +213,9 @@ class SamplerComboNode(ComfyAssetsBaseNode):
             "recommendation": f"Recommended range: {min_cfg}-{max_cfg} CFG",
         }
 
-    def get_combo_analysis(self, sampler_name: str, scheduler: str, steps: int, cfg: float) -> dict:
+    def get_combo_analysis(
+        self, sampler_name: str, scheduler: str, steps: int, cfg: float
+    ) -> dict:
         """
         Analyze the sampler combo configuration and provide recommendations.
 
@@ -264,7 +274,10 @@ class SamplerComboNode(ComfyAssetsBaseNode):
 
     def __str__(self) -> str:
         """String representation of the node."""
-        return f"SamplerComboNode(samplers={len(SAMPLERS)}, " f"schedulers={len(SCHEDULERS)})"
+        return (
+            f"SamplerComboNode(samplers={len(SAMPLERS)}, "
+            f"schedulers={len(SCHEDULERS)})"
+        )
 
     def __repr__(self) -> str:
         """Detailed string representation of the node."""

kikotools/tools/seed_history/logic.py

@@ -66,7 +66,9 @@ def sanitize_seed_value(seed: Any) -> int:
         raise ValueError(f"Invalid seed value: {seed}") from e
 
 
-def create_history_entry(seed: int, timestamp: Optional[float] = None) -> Dict[str, Any]:
+def create_history_entry(
+    seed: int, timestamp: Optional[float] = None
+) -> Dict[str, Any]:
     """
     Create a standardized history entry for a seed.
 
@@ -87,7 +89,9 @@ def create_history_entry(seed: int, timestamp: Optional[float] = None) -> Dict[s
     }
 
 
-def filter_duplicate_seeds(history: List[Dict[str, Any]], new_seed: int, dedup_window_ms: int = 500) -> bool:
+def filter_duplicate_seeds(
+    history: List[Dict[str, Any]], new_seed: int, dedup_window_ms: int = 500
+) -> bool:
     """
     Check if a seed should be filtered as a duplicate.
 
@@ -189,7 +193,9 @@ def format_time_ago(timestamp: float) -> str:
         return f"{seconds}s ago"
 
 
-def search_history_by_seed(history: List[Dict[str, Any]], seed: int) -> Optional[Dict[str, Any]]:
+def search_history_by_seed(
+    history: List[Dict[str, Any]], seed: int
+) -> Optional[Dict[str, Any]]:
     """
     Search history for a specific seed value.
 

kikotools/tools/seed_history/node.py

@@ -28,7 +28,8 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
                         "default": 12345,
                         "min": 0,
                         "max": 0xFFFFFFFFFFFFFFFF,
-                        "tooltip": "Seed value for generation processes. " "History UI tracks all changes automatically.",
+                        "tooltip": "Seed value for generation processes. "
+                        "History UI tracks all changes automatically.",
                     },
                 ),
             }
@@ -56,7 +57,10 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
                 import logging
 
                 logger = logging.getLogger(__name__)
-                logger.error(f"{self.__class__.__name__}: Invalid seed value: {seed}. " f"Using fallback seed 12345.")
+                logger.error(
+                    f"{self.__class__.__name__}: Invalid seed value: {seed}. "
+                    f"Using fallback seed 12345."
+                )
                 return (12345,)
 
             clean_seed = sanitize_seed_value(seed)
@@ -68,7 +72,10 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
             import logging
 
             logger = logging.getLogger(__name__)
-            logger.error(f"{self.__class__.__name__}: Error processing seed: {str(e)}. " f"Using fallback seed 12345.")
+            logger.error(
+                f"{self.__class__.__name__}: Error processing seed: {str(e)}. "
+                f"Using fallback seed 12345."
+            )
             return (12345,)
 
     def generate_new_seed(self) -> int:

kikotools/tools/width_height_selector/logic.py

@@ -5,7 +5,9 @@ from math import gcd
 from .presets import PRESET_OPTIONS
 
 
-def get_preset_dimensions(preset: str, custom_width: int, custom_height: int) -> Tuple[int, int]:
+def get_preset_dimensions(
+    preset: str, custom_width: int, custom_height: int
+) -> Tuple[int, int]:
     """
     Get dimensions from preset name or use custom dimensions.
 
@@ -112,7 +114,9 @@ def sanitize_dimensions(width: int, height: int) -> Tuple[int, int]:
     return width, height
 
 
-def get_dimension_info(preset: str, width: int, height: int, swap_enabled: bool) -> dict:
+def get_dimension_info(
+    preset: str, width: int, height: int, swap_enabled: bool
+) -> dict:
     """
     Get comprehensive dimension information including metadata.
 
@@ -201,7 +205,9 @@ def parse_dimension_string(dimension_str: str) -> Tuple[int, int]:
         raise ValueError(f"Could not parse dimensions from {dimension_str}: {e}")
 
 
-def get_optimal_scale_factor(current_width: int, current_height: int, target_width: int, target_height: int) -> float:
+def get_optimal_scale_factor(
+    current_width: int, current_height: int, target_width: int, target_height: int
+) -> float:
     """
     Calculate optimal scale factor to get from current to target dimensions.
 

kikotools/tools/width_height_selector/node.py

@@ -36,7 +36,8 @@ class WidthHeightSelectorNode(ComfyAssetsBaseNode):
                 metadata = PRESET_METADATA.get(preset_name)
                 if metadata:
                     formatted_option = (
-                        f"{preset_name} - {metadata.aspect_ratio} " f"({metadata.megapixels:.1f}MP) - {metadata.model_group}"
+                        f"{preset_name} - {metadata.aspect_ratio} "
+                        f"({metadata.megapixels:.1f}MP) - {metadata.model_group}"
                     )
                     preset_options.append(formatted_option)
                 else:
@@ -103,7 +104,9 @@ class WidthHeightSelectorNode(ComfyAssetsBaseNode):
             original_preset = self._extract_preset_name(preset)
 
             # Get base dimensions from preset or custom input
-            final_width, final_height = get_preset_dimensions(original_preset, width, height)
+            final_width, final_height = get_preset_dimensions(
+                original_preset, width, height
+            )
 
             # Sanitize dimensions to ensure they meet ComfyUI requirements
             final_width, final_height = sanitize_dimensions(final_width, final_height)
@@ -112,7 +115,8 @@ class WidthHeightSelectorNode(ComfyAssetsBaseNode):
             if not validate_dimensions(final_width, final_height):
                 # This should not happen after sanitization, but handle gracefully
                 self.handle_error(
-                    f"Generated invalid dimensions: {final_width}×{final_height}. " f"Using fallback dimensions 1024×1024."
+                    f"Generated invalid dimensions: {final_width}×{final_height}. "
+                    f"Using fallback dimensions 1024×1024."
                 )
                 final_width, final_height = 1024, 1024
 
@@ -120,7 +124,9 @@ class WidthHeightSelectorNode(ComfyAssetsBaseNode):
 
         except Exception as e:
             # Handle any unexpected errors gracefully
-            error_msg = f"Error processing dimensions: {str(e)}. Using fallback 1024×1024."
+            error_msg = (
+                f"Error processing dimensions: {str(e)}. Using fallback 1024×1024."
+            )
             self.handle_error(error_msg)
             return (1024, 1024)
 
@@ -170,7 +176,10 @@ class WidthHeightSelectorNode(ComfyAssetsBaseNode):
 
         metadata = get_preset_metadata(preset)
         if metadata.width > 0:  # Valid metadata
-            return f"{preset} - {metadata.aspect_ratio} ({metadata.megapixels:.1f}MP) - " f"{metadata.description}"
+            return (
+                f"{preset} - {metadata.aspect_ratio} ({metadata.megapixels:.1f}MP) - "
+                f"{metadata.description}"
+            )
 
         return f"Unknown preset: {preset}"
 

kikotools/tools/width_height_selector/presets.py

@@ -287,15 +287,21 @@ PRESET_METADATA: Dict[str, PresetMetadata] = {
 
 # Legacy compatibility - maintain old preset dictionaries
 SDXL_PRESETS: Dict[str, Tuple[int, int]] = {
-    k: (v.width, v.height) for k, v in PRESET_METADATA.items() if v.model_group == "SDXL"
+    k: (v.width, v.height)
+    for k, v in PRESET_METADATA.items()
+    if v.model_group == "SDXL"
 }
 
 FLUX_PRESETS: Dict[str, Tuple[int, int]] = {
-    k: (v.width, v.height) for k, v in PRESET_METADATA.items() if v.model_group == "FLUX"
+    k: (v.width, v.height)
+    for k, v in PRESET_METADATA.items()
+    if v.model_group == "FLUX"
 }
 
 ULTRA_WIDE_PRESETS: Dict[str, Tuple[int, int]] = {
-    k: (v.width, v.height) for k, v in PRESET_METADATA.items() if v.model_group == "Ultra-Wide"
+    k: (v.width, v.height)
+    for k, v in PRESET_METADATA.items()
+    if v.model_group == "Ultra-Wide"
 }
 
 # Combined preset options for ComfyUI dropdown
@@ -308,28 +314,78 @@ PRESET_OPTIONS: Dict[str, Tuple[int, int]] = {
 PRESET_CATEGORIES = {
     "Custom": ["custom"],
     # SDXL Categories
-    "SDXL Square": [k for k, v in PRESET_METADATA.items() if v.model_group == "SDXL" and v.category == "Square"],
-    "SDXL Portrait": [k for k, v in PRESET_METADATA.items() if v.model_group == "SDXL" and v.category == "Portrait"],
-    "SDXL Landscape": [k for k, v in PRESET_METADATA.items() if v.model_group == "SDXL" and v.category == "Landscape"],
+    "SDXL Square": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "SDXL" and v.category == "Square"
+    ],
+    "SDXL Portrait": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "SDXL" and v.category == "Portrait"
+    ],
+    "SDXL Landscape": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "SDXL" and v.category == "Landscape"
+    ],
     # FLUX Categories
-    "FLUX Square": [k for k, v in PRESET_METADATA.items() if v.model_group == "FLUX" and v.category == "Square"],
-    "FLUX Portrait": [k for k, v in PRESET_METADATA.items() if v.model_group == "FLUX" and v.category == "Portrait"],
-    "FLUX Cinematic": [k for k, v in PRESET_METADATA.items() if v.model_group == "FLUX" and v.category == "Cinematic"],
-    "FLUX Classic": [k for k, v in PRESET_METADATA.items() if v.model_group == "FLUX" and v.category == "Classic"],
-    "FLUX Photography": [k for k, v in PRESET_METADATA.items() if v.model_group == "FLUX" and v.category == "Photography"],
+    "FLUX Square": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "FLUX" and v.category == "Square"
+    ],
+    "FLUX Portrait": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "FLUX" and v.category == "Portrait"
+    ],
+    "FLUX Cinematic": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "FLUX" and v.category == "Cinematic"
+    ],
+    "FLUX Classic": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "FLUX" and v.category == "Classic"
+    ],
+    "FLUX Photography": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "FLUX" and v.category == "Photography"
+    ],
     # Ultra-Wide Categories
-    "Ultra-Wide Gaming": [k for k, v in PRESET_METADATA.items() if v.model_group == "Ultra-Wide" and v.category == "Gaming"],
+    "Ultra-Wide Gaming": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "Ultra-Wide" and v.category == "Gaming"
+    ],
     "Ultra-Wide Cinematic": [
-        k for k, v in PRESET_METADATA.items() if v.model_group == "Ultra-Wide" and v.category == "Cinematic"
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "Ultra-Wide" and v.category == "Cinematic"
     ],
     "Ultra-Wide Panoramic": [
-        k for k, v in PRESET_METADATA.items() if v.model_group == "Ultra-Wide" and v.category == "Panoramic"
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "Ultra-Wide" and v.category == "Panoramic"
+    ],
+    "Ultra-Wide Mobile": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "Ultra-Wide" and v.category == "Mobile"
     ],
-    "Ultra-Wide Mobile": [k for k, v in PRESET_METADATA.items() if v.model_group == "Ultra-Wide" and v.category == "Mobile"],
     "Ultra-Wide Vertical": [
-        k for k, v in PRESET_METADATA.items() if v.model_group == "Ultra-Wide" and v.category == "Vertical"
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "Ultra-Wide" and v.category == "Vertical"
+    ],
+    "Ultra-Wide Banner": [
+        k
+        for k, v in PRESET_METADATA.items()
+        if v.model_group == "Ultra-Wide" and v.category == "Banner"
     ],
-    "Ultra-Wide Banner": [k for k, v in PRESET_METADATA.items() if v.model_group == "Ultra-Wide" and v.category == "Banner"],
 }
 
 # Legacy compatibility - preset descriptions
@@ -339,7 +395,9 @@ PRESET_DESCRIPTIONS = {k: v.description for k, v in PRESET_METADATA.items()}
 MODEL_RECOMMENDATIONS = {
     "SDXL": [k for k, v in PRESET_METADATA.items() if v.model_group == "SDXL"],
     "FLUX": [k for k, v in PRESET_METADATA.items() if v.model_group == "FLUX"],
-    "Ultra-Wide": [k for k, v in PRESET_METADATA.items() if v.model_group == "Ultra-Wide"],
+    "Ultra-Wide": [
+        k for k, v in PRESET_METADATA.items() if v.model_group == "Ultra-Wide"
+    ],
 }
 
 
@@ -393,7 +451,9 @@ def validate_preset_dimensions() -> bool:
 
         # Check divisible by 8
         if width % 8 != 0 or height % 8 != 0:
-            print(f"ERROR: {preset_name} dimensions not divisible by 8: {width}×{height}")
+            print(
+                f"ERROR: {preset_name} dimensions not divisible by 8: {width}×{height}"
+            )
             return False
 
         # Check reasonable bounds
@@ -409,7 +469,9 @@ def validate_metadata_consistency() -> bool:
     """Validate metadata consistency and completeness."""
     for preset_name, metadata in PRESET_METADATA.items():
         # Verify aspect ratio calculation
-        expected_ratio, expected_decimal = calculate_aspect_ratio(metadata.width, metadata.height)
+        expected_ratio, expected_decimal = calculate_aspect_ratio(
+            metadata.width, metadata.height
+        )
         if abs(metadata.aspect_decimal - expected_decimal) > 0.001:
             print(
                 f"ERROR: {preset_name} aspect ratio mismatch: "
@@ -420,7 +482,10 @@ def validate_metadata_consistency() -> bool:
         # Verify megapixel calculation
         expected_mp = (metadata.width * metadata.height) / 1_000_000
         if abs(metadata.megapixels - expected_mp) > 0.1:
-            print(f"ERROR: {preset_name} megapixel mismatch: " f"expected {expected_mp:.2f}, got {metadata.megapixels}")
+            print(
+                f"ERROR: {preset_name} megapixel mismatch: "
+                f"expected {expected_mp:.2f}, got {metadata.megapixels}"
+            )
             return False
 
     return True

tests/conftest.py

@@ -102,12 +102,18 @@ def assert_divisible_by_8(width: int, height: int) -> None:
     assert height % 8 == 0, f"Height {height} must be divisible by 8"
 
 
-def assert_reasonable_dimensions(width: int, height: int, min_size: int = 64, max_size: int = 8192) -> None:
+def assert_reasonable_dimensions(
+    width: int, height: int, min_size: int = 64, max_size: int = 8192
+) -> None:
     """
     Helper function to assert dimensions are within reasonable bounds
     """
-    assert min_size <= width <= max_size, f"Width {width} out of reasonable range [{min_size}, {max_size}]"
-    assert min_size <= height <= max_size, f"Height {height} out of reasonable range [{min_size}, {max_size}]"
+    assert (
+        min_size <= width <= max_size
+    ), f"Width {width} out of reasonable range [{min_size}, {max_size}]"
+    assert (
+        min_size <= height <= max_size
+    ), f"Height {height} out of reasonable range [{min_size}, {max_size}]"
 
 
 # Make helper functions available as pytest fixtures

tests/unit/test_base_node.py

@@ -32,7 +32,10 @@ class TestComfyAssetsBaseNode:
                 node.handle_error("Test error message")
 
             mock_logger.error.assert_called_once()
-            assert "ComfyAssetsBaseNode: Test error message" in mock_logger.error.call_args[0][0]
+            assert (
+                "ComfyAssetsBaseNode: Test error message"
+                in mock_logger.error.call_args[0][0]
+            )
 
     def test_handle_error_with_exception_logs_exception(self):
         """Test error handling with original exception logs both messages"""
@@ -55,7 +58,10 @@ class TestComfyAssetsBaseNode:
             node.log_info("Test information")
 
             mock_logger.info.assert_called_once()
-            assert "ComfyAssetsBaseNode: Test information" in mock_logger.info.call_args[0][0]
+            assert (
+                "ComfyAssetsBaseNode: Test information"
+                in mock_logger.info.call_args[0][0]
+            )
 
     def test_get_node_info_returns_metadata(self):
         """Test get_node_info returns correct metadata"""

tests/unit/tools/test_gemini_prompt.py

@@ -0,0 +1,280 @@
+"""Unit tests for Gemini Prompt Engineer node."""
+
+import pytest
+import numpy as np
+from unittest.mock import patch, MagicMock
+from PIL import Image
+
+from kikotools.tools.gemini_prompt import GeminiPromptNode
+from kikotools.tools.gemini_prompt.logic import (
+    tensor_to_pil,
+    image_to_base64,
+    get_api_key,
+    validate_prompt_type,
+    analyze_image_with_gemini,
+)
+from kikotools.tools.gemini_prompt.prompts import (
+    PROMPT_OPTIONS,
+    PROMPT_TEMPLATES,
+    GEMINI_MODELS,
+)
+
+
+class TestGeminiPromptNode:
+    """Test cases for GeminiPromptNode."""
+
+    def test_node_properties(self):
+        """Test node has correct properties."""
+        assert GeminiPromptNode.CATEGORY == "ComfyAssets"
+        assert GeminiPromptNode.FUNCTION == "generate_prompt"
+        assert GeminiPromptNode.RETURN_TYPES == ("STRING", "STRING")
+        assert GeminiPromptNode.RETURN_NAMES == ("prompt", "negative_prompt")
+
+    def test_input_types(self):
+        """Test INPUT_TYPES configuration."""
+        input_types = GeminiPromptNode.INPUT_TYPES()
+
+        # Check required inputs
+        assert "required" in input_types
+        assert "image" in input_types["required"]
+        assert input_types["required"]["image"] == ("IMAGE",)
+        assert "prompt_type" in input_types["required"]
+        assert input_types["required"]["prompt_type"][0] == PROMPT_OPTIONS
+        assert "model" in input_types["required"]
+        assert input_types["required"]["model"][0] == GEMINI_MODELS
+
+        # Check optional inputs
+        assert "optional" in input_types
+        assert "api_key" in input_types["optional"]
+        assert "custom_prompt" in input_types["optional"]
+
+    def test_gemini_models_available(self):
+        """Test that all expected Gemini models are available."""
+        expected_models = [
+            "gemini-1.5-pro",
+            "gemini-1.5-flash",
+            "gemini-1.5-flash-8b",
+            "gemini-pro-vision",
+            "gemini-1.0-pro",
+        ]
+        for model in expected_models:
+            assert model in GEMINI_MODELS
+
+    @patch("kikotools.tools.gemini_prompt.node.analyze_image_with_gemini")
+    def test_generate_prompt_success(self, mock_analyze):
+        """Test successful prompt generation."""
+        # Setup
+        node = GeminiPromptNode()
+        test_image = np.random.rand(1, 512, 512, 3).astype(np.float32)
+        mock_analyze.return_value = ("A beautiful landscape with mountains", None)
+
+        # Execute
+        result = node.generate_prompt(test_image, "flux")
+
+        # Assert
+        assert result == ("A beautiful landscape with mountains", "")
+        mock_analyze.assert_called_once()
+
+    @patch("kikotools.tools.gemini_prompt.node.analyze_image_with_gemini")
+    def test_generate_prompt_sdxl_format(self, mock_analyze):
+        """Test SDXL format with positive and negative prompts."""
+        # Setup
+        node = GeminiPromptNode()
+        test_image = np.random.rand(1, 512, 512, 3).astype(np.float32)
+        mock_analyze.return_value = (
+            "Positive: beautiful landscape, mountains, sunset\nNegative: blurry, low quality",
+            None,
+        )
+
+        # Execute
+        result = node.generate_prompt(test_image, "sdxl")
+
+        # Assert
+        assert result == (
+            "beautiful landscape, mountains, sunset",
+            "blurry, low quality",
+        )
+
+    @patch("kikotools.tools.gemini_prompt.node.analyze_image_with_gemini")
+    def test_generate_prompt_error(self, mock_analyze):
+        """Test error handling in prompt generation."""
+        # Setup
+        node = GeminiPromptNode()
+        test_image = np.random.rand(1, 512, 512, 3).astype(np.float32)
+        mock_analyze.return_value = ("", "API key not found")
+
+        # Execute
+        result = node.generate_prompt(test_image, "flux")
+
+        # Assert
+        assert result[0].startswith("Error:")
+        assert result[1] == ""
+
+    def test_invalid_prompt_type(self):
+        """Test handling of invalid prompt type."""
+        node = GeminiPromptNode()
+        test_image = np.random.rand(1, 512, 512, 3).astype(np.float32)
+
+        with pytest.raises(ValueError, match="Invalid prompt type"):
+            node.generate_prompt(test_image, "invalid_type")
+
+
+class TestGeminiLogic:
+    """Test cases for Gemini logic functions."""
+
+    def test_tensor_to_pil(self):
+        """Test tensor to PIL conversion."""
+        # Test 4D tensor
+        tensor_4d = np.random.rand(1, 64, 64, 3)
+        result = tensor_to_pil(tensor_4d)
+        assert isinstance(result, Image.Image)
+        assert result.size == (64, 64)
+        assert result.mode == "RGB"
+
+        # Test 3D tensor
+        tensor_3d = np.random.rand(64, 64, 3)
+        result = tensor_to_pil(tensor_3d)
+        assert isinstance(result, Image.Image)
+        assert result.size == (64, 64)
+
+    def test_image_to_base64(self):
+        """Test image to base64 conversion."""
+        # Create test image
+        image = Image.new("RGB", (64, 64), color="red")
+
+        # Convert to base64
+        result = image_to_base64(image)
+        assert isinstance(result, str)
+        assert len(result) > 0
+
+        # Test JPEG format
+        result_jpeg = image_to_base64(image, format="JPEG")
+        assert isinstance(result_jpeg, str)
+        assert (
+            result != result_jpeg
+        )  # Different formats should produce different results
+
+    @patch.dict("os.environ", {"GEMINI_API_KEY": "test_key_123"})
+    def test_get_api_key_from_env(self):
+        """Test getting API key from environment."""
+        result = get_api_key()
+        assert result == "test_key_123"
+
+    @patch.dict("os.environ", {}, clear=True)
+    @patch("os.path.exists")
+    @patch("builtins.open")
+    def test_get_api_key_from_config(self, mock_open, mock_exists):
+        """Test getting API key from config file."""
+        # Setup
+        mock_exists.return_value = True
+        mock_open.return_value.__enter__.return_value.read.return_value = (
+            '{"api_key": "config_key_456"}'
+        )
+
+        # Execute
+        result = get_api_key()
+
+        # Assert
+        assert result == "config_key_456"
+
+    def test_validate_prompt_type(self):
+        """Test prompt type validation."""
+        # Valid types
+        for prompt_type in PROMPT_OPTIONS:
+            assert validate_prompt_type(prompt_type) is True
+
+        # Invalid types
+        assert validate_prompt_type("invalid") is False
+        assert validate_prompt_type("") is False
+        assert validate_prompt_type(None) is False
+
+    @patch("google.generativeai.configure")
+    @patch("google.generativeai.GenerativeModel")
+    def test_analyze_image_with_gemini_success(self, mock_model_class, mock_configure):
+        """Test successful image analysis with Gemini."""
+        # Setup
+        mock_model = MagicMock()
+        mock_response = MagicMock()
+        mock_response.text = "A beautiful sunset over mountains"
+        mock_model.generate_content.return_value = mock_response
+        mock_model_class.return_value = mock_model
+
+        test_image = np.random.rand(64, 64, 3)
+
+        # Execute
+        result, error = analyze_image_with_gemini(
+            test_image, "flux", api_key="test_key"
+        )
+
+        # Assert
+        assert result == "A beautiful sunset over mountains"
+        assert error is None
+        mock_configure.assert_called_once_with(api_key="test_key")
+        mock_model.generate_content.assert_called_once()
+
+    def test_analyze_image_no_api_key(self):
+        """Test analysis without API key."""
+        test_image = np.random.rand(64, 64, 3)
+
+        with patch(
+            "kikotools.tools.gemini_prompt.logic.get_api_key", return_value=None
+        ):
+            result, error = analyze_image_with_gemini(test_image, "flux")
+
+        assert result == ""
+        assert "API key not found" in error
+
+    @patch("google.generativeai.configure")
+    @patch("google.generativeai.GenerativeModel")
+    def test_analyze_image_with_custom_prompt(self, mock_model_class, mock_configure):
+        """Test analysis with custom prompt."""
+        # Setup
+        mock_model = MagicMock()
+        mock_response = MagicMock()
+        mock_response.text = "Custom analysis result"
+        mock_model.generate_content.return_value = mock_response
+        mock_model_class.return_value = mock_model
+
+        test_image = np.random.rand(64, 64, 3)
+        custom_prompt = "Analyze this image and describe the colors"
+
+        # Execute
+        result, error = analyze_image_with_gemini(
+            test_image, "flux", api_key="test_key", custom_prompt=custom_prompt
+        )
+
+        # Assert
+        assert result == "Custom analysis result"
+        assert error is None
+
+        # Check that custom prompt was used
+        call_args = mock_model.generate_content.call_args[0][0]
+        assert custom_prompt in call_args
+
+
+class TestPromptTemplates:
+    """Test prompt template configurations."""
+
+    def test_all_prompt_types_have_templates(self):
+        """Test that all prompt options have corresponding templates."""
+        for prompt_type in PROMPT_OPTIONS:
+            assert prompt_type in PROMPT_TEMPLATES
+            assert isinstance(PROMPT_TEMPLATES[prompt_type], str)
+            assert len(PROMPT_TEMPLATES[prompt_type]) > 0
+
+    def test_prompt_template_content(self):
+        """Test that prompt templates contain expected content."""
+        # FLUX prompt should mention FLUX
+        assert "FLUX" in PROMPT_TEMPLATES["flux"]
+
+        # SDXL prompt should mention positive and negative
+        assert "Positive" in PROMPT_TEMPLATES["sdxl"]
+        assert "Negative" in PROMPT_TEMPLATES["sdxl"]
+
+        # Danbooru should mention tags and underscores
+        assert "tag" in PROMPT_TEMPLATES["danbooru"].lower()
+        assert "underscore" in PROMPT_TEMPLATES["danbooru"].lower()
+
+        # Video should mention motion and temporal
+        assert "motion" in PROMPT_TEMPLATES["video"].lower()
+        assert "temporal" in PROMPT_TEMPLATES["video"].lower()

tests/unit/tools/test_kiko_save_image.py

@@ -52,7 +52,9 @@ class TestKikoSaveImageLogic:
         """Test save path generation"""
         with tempfile.TemporaryDirectory() as temp_dir:
             # Test basic path generation
-            full_path, filename = get_save_image_path("test_prefix", 0, ".png", temp_dir)
+            full_path, filename = get_save_image_path(
+                "test_prefix", 0, ".png", temp_dir
+            )
 
             assert full_path.startswith(temp_dir)
             assert filename.startswith("test_prefix_")
@@ -211,20 +213,28 @@ class TestKikoSaveImageLogic:
         images = torch.rand(1, 32, 32, 3)
 
         # Quality out of range
-        with pytest.raises(ValueError, match="quality must be an integer between 1 and 100"):
+        with pytest.raises(
+            ValueError, match="quality must be an integer between 1 and 100"
+        ):
             validate_save_inputs(images, "JPEG", 0, 4)
 
-        with pytest.raises(ValueError, match="quality must be an integer between 1 and 100"):
+        with pytest.raises(
+            ValueError, match="quality must be an integer between 1 and 100"
+        ):
             validate_save_inputs(images, "JPEG", 101, 4)
 
     def test_validate_save_inputs_invalid_compress_level(self):
         """Test validation with invalid PNG compression level"""
         images = torch.rand(1, 32, 32, 3)
 
-        with pytest.raises(ValueError, match="png_compress_level must be an integer between 0 and 9"):
+        with pytest.raises(
+            ValueError, match="png_compress_level must be an integer between 0 and 9"
+        ):
             validate_save_inputs(images, "PNG", 90, -1)
 
-        with pytest.raises(ValueError, match="png_compress_level must be an integer between 0 and 9"):
+        with pytest.raises(
+            ValueError, match="png_compress_level must be an integer between 0 and 9"
+        ):
             validate_save_inputs(images, "PNG", 90, 10)
 
     def test_save_image_with_format_png(self):

tests/unit/tools/test_resolution_calculator.py

@@ -56,9 +56,13 @@ class TestDimensionExtraction:
         with pytest.raises(ValueError, match="Either image or latent must be provided"):
             extract_dimensions()
 
-    def test_extract_dimensions_both_inputs_prefers_image(self, mock_image_tensor, mock_latent_tensor):
+    def test_extract_dimensions_both_inputs_prefers_image(
+        self, mock_image_tensor, mock_latent_tensor
+    ):
         """Test that when both inputs provided, image takes precedence"""
-        width, height = extract_dimensions(image=mock_image_tensor, latent=mock_latent_tensor)
+        width, height = extract_dimensions(
+            image=mock_image_tensor, latent=mock_latent_tensor
+        )
 
         # Should return image dimensions, not latent
         assert width == 832
@@ -89,7 +93,9 @@ class TestScaledDimensionsCalculation:
         original_width, original_height = 832, 1216
         scale_factor = 1.5
 
-        new_width, new_height = calculate_scaled_dimensions(original_width, original_height, scale_factor)
+        new_width, new_height = calculate_scaled_dimensions(
+            original_width, original_height, scale_factor
+        )
 
         # Check aspect ratio is preserved (within floating point precision)
         original_ratio = original_width / original_height
@@ -101,7 +107,9 @@ class TestScaledDimensionsCalculation:
         base_width, base_height = 1024, 1024
 
         for scale_factor in sample_scale_factors:
-            width, height = calculate_scaled_dimensions(base_width, base_height, scale_factor)
+            width, height = calculate_scaled_dimensions(
+                base_width, base_height, scale_factor
+            )
 
             expected_width = int(base_width * scale_factor)
             expected_height = int(base_height * scale_factor)
@@ -205,7 +213,9 @@ class TestResolutionCalculatorNode:
         """Test node calculation with IMAGE input"""
         node = ResolutionCalculatorNode()
 
-        width, height = node.calculate_resolution(scale_factor=2.0, image=mock_image_tensor)
+        width, height = node.calculate_resolution(
+            scale_factor=2.0, image=mock_image_tensor
+        )
 
         # Original: 832x1216, 2x scale = 1664x2432
         assert isinstance(width, int)
@@ -220,7 +230,9 @@ class TestResolutionCalculatorNode:
         """Test node calculation with LATENT input"""
         node = ResolutionCalculatorNode()
 
-        width, height = node.calculate_resolution(scale_factor=1.5, latent=mock_latent_tensor)
+        width, height = node.calculate_resolution(
+            scale_factor=1.5, latent=mock_latent_tensor
+        )
 
         # Original: 832x1216, 1.5x scale = 1248x1824
         assert isinstance(width, int)
@@ -238,12 +250,16 @@ class TestResolutionCalculatorNode:
         with pytest.raises(ValueError):
             node.calculate_resolution(scale_factor=2.0)
 
-    def test_calculate_resolution_with_various_scale_factors(self, mock_image_tensor_square, sample_scale_factors):
+    def test_calculate_resolution_with_various_scale_factors(
+        self, mock_image_tensor_square, sample_scale_factors
+    ):
         """Test calculation with various scale factors"""
         node = ResolutionCalculatorNode()
 
         for scale_factor in sample_scale_factors:
-            width, height = node.calculate_resolution(scale_factor=scale_factor, image=mock_image_tensor_square)
+            width, height = node.calculate_resolution(
+                scale_factor=scale_factor, image=mock_image_tensor_square
+            )
 
             # All results should be integers divisible by 8
             assert isinstance(width, int)

tests/unit/tools/test_sampler_combo.py

@@ -331,7 +331,9 @@ class TestSamplerComboIntegration:
 
             # Test that recommendations work with the node
             for scheduler in suggestions[:2]:  # Test first 2 suggestions
-                result = node.get_sampler_combo(sampler, scheduler, steps_rec["default"], cfg_rec["default"])
+                result = node.get_sampler_combo(
+                    sampler, scheduler, steps_rec["default"], cfg_rec["default"]
+                )
                 assert result[0] == sampler
                 assert result[1] == scheduler
                 assert result[2] == steps_rec["default"]

tests/unit/tools/test_width_height_selector.py

@@ -70,7 +70,9 @@ class TestWidthHeightSelectorNode:
 
         # Test formatted preset if available
         formatted_preset = "832×1216 - 13:19 (1.0MP) - SDXL"
-        result = self.node.get_dimensions(preset=formatted_preset, width=512, height=512)
+        result = self.node.get_dimensions(
+            preset=formatted_preset, width=512, height=512
+        )
         assert result == (832, 1216)
 
     def test_sdxl_landscape_preset(self):
@@ -81,7 +83,9 @@ class TestWidthHeightSelectorNode:
 
         # Test formatted preset if available
         formatted_preset = "1216×832 - 19:13 (1.0MP) - SDXL"
-        result = self.node.get_dimensions(preset=formatted_preset, width=512, height=512)
+        result = self.node.get_dimensions(
+            preset=formatted_preset, width=512, height=512
+        )
         assert result == (1216, 832)
 
     def test_flux_preset(self):
@@ -92,7 +96,9 @@ class TestWidthHeightSelectorNode:
 
         # Test formatted preset
         formatted_preset = "1920×1080 - 16:9 (2.1MP) - FLUX"
-        result = self.node.get_dimensions(preset=formatted_preset, width=512, height=512)
+        result = self.node.get_dimensions(
+            preset=formatted_preset, width=512, height=512
+        )
         assert result == (1920, 1080)
 
     def test_ultra_wide_preset(self):
@@ -103,7 +109,9 @@ class TestWidthHeightSelectorNode:
 
         # Test formatted preset if available
         formatted_preset = "2560×1080 - 64:27 (2.8MP) - Ultra-Wide"
-        result = self.node.get_dimensions(preset=formatted_preset, width=512, height=512)
+        result = self.node.get_dimensions(
+            preset=formatted_preset, width=512, height=512
+        )
         assert result == (2560, 1080)
 
     def test_all_presets_available(self):
@@ -135,7 +143,9 @@ class TestWidthHeightSelectorNode:
     def test_invalid_preset_fallback(self):
         """Test handling of invalid preset."""
         # Should fall back to custom dimensions
-        result = self.node.get_dimensions(preset="invalid_preset", width=800, height=600)
+        result = self.node.get_dimensions(
+            preset="invalid_preset", width=800, height=600
+        )
         assert result == (800, 600)
 
 
@@ -258,14 +268,18 @@ class TestPresetDefinitions:
         for preset_dict in [SDXL_PRESETS, FLUX_PRESETS, ULTRA_WIDE_PRESETS]:
             for preset_name, (width, height) in preset_dict.items():
                 assert width % 8 == 0, f"{preset_name} width {width} not divisible by 8"
-                assert height % 8 == 0, f"{preset_name} height {height} not divisible by 8"
+                assert (
+                    height % 8 == 0
+                ), f"{preset_name} height {height} not divisible by 8"
 
     def test_preset_dimensions_within_limits(self):
         """Test that all preset dimensions are within acceptable limits."""
         for preset_dict in [SDXL_PRESETS, FLUX_PRESETS, ULTRA_WIDE_PRESETS]:
             for preset_name, (width, height) in preset_dict.items():
                 assert 64 <= width <= 8192, f"{preset_name} width {width} out of range"
-                assert 64 <= height <= 8192, f"{preset_name} height {height} out of range"
+                assert (
+                    64 <= height <= 8192
+                ), f"{preset_name} height {height} out of range"
 
 
 class TestEdgeCases:
@@ -467,7 +481,9 @@ class TestFormattedPresets:
 
         for formatted_preset, expected in test_cases:
             result = self.node._extract_preset_name(formatted_preset)
-            assert result == expected, f"Expected {expected}, got {result} for input {formatted_preset}"
+            assert (
+                result == expected
+            ), f"Expected {expected}, got {result} for input {formatted_preset}"
 
     def test_formatted_preset_dimensions(self):
         """Test that formatted presets return correct dimensions."""
@@ -509,22 +525,34 @@ class TestFormattedPresets:
     def test_formatted_preset_metadata_accuracy(self):
         """Test that formatted presets contain accurate metadata."""
         input_types = self.node.INPUT_TYPES()
-        formatted_presets = [opt for opt in input_types["required"]["preset"][0] if " - " in opt]
+        formatted_presets = [
+            opt for opt in input_types["required"]["preset"][0] if " - " in opt
+        ]
 
         for formatted_preset in formatted_presets:
             # Extract components
             parts = formatted_preset.split(" - ")
-            assert len(parts) == 3, f"Formatted preset should have 3 parts: {formatted_preset}"
+            assert (
+                len(parts) == 3
+            ), f"Formatted preset should have 3 parts: {formatted_preset}"
 
             resolution = parts[0]
             aspect_and_mp = parts[1]
             model_group = parts[2]
 
             # Verify resolution exists in metadata
-            assert resolution in PRESET_METADATA, f"Resolution {resolution} not in metadata"
+            assert (
+                resolution in PRESET_METADATA
+            ), f"Resolution {resolution} not in metadata"
 
             # Verify metadata matches format
             metadata = PRESET_METADATA[resolution]
-            assert metadata.model_group == model_group, f"Model group mismatch for {resolution}"
-            assert metadata.aspect_ratio in aspect_and_mp, f"Aspect ratio not in {aspect_and_mp}"
-            assert f"{metadata.megapixels:.1f}MP" in aspect_and_mp, f"Megapixels not in {aspect_and_mp}"
+            assert (
+                metadata.model_group == model_group
+            ), f"Model group mismatch for {resolution}"
+            assert (
+                metadata.aspect_ratio in aspect_and_mp
+            ), f"Aspect ratio not in {aspect_and_mp}"
+            assert (
+                f"{metadata.megapixels:.1f}MP" in aspect_and_mp
+            ), f"Megapixels not in {aspect_and_mp}"

web/gemini_prompt_ui.js

@@ -0,0 +1,176 @@
+import { app } from "../../../scripts/app.js";
+import { api } from "../../../scripts/api.js";
+
+app.registerExtension({
+    name: "ComfyAssets.GeminiPrompt",
+    
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (nodeData.name === "GeminiPrompt") {
+            // Add visual enhancements to the node
+            const onNodeCreated = nodeType.prototype.onNodeCreated;
+            
+            nodeType.prototype.onNodeCreated = function() {
+                const result = onNodeCreated?.apply(this, arguments);
+                
+                // Store reference to widgets
+                this.promptTypeWidget = this.widgets.find(w => w.name === "prompt_type");
+                this.modelWidget = this.widgets.find(w => w.name === "model");
+                this.apiKeyWidget = this.widgets.find(w => w.name === "api_key");
+                this.customPromptWidget = this.widgets.find(w => w.name === "custom_prompt");
+                
+                // Add helper text button
+                const helpButton = this.addWidget("button", "Help / API Setup", null, () => {
+                    this.showHelpDialog();
+                });
+                
+                // Style the button
+                helpButton.serialize = false;
+                
+                // Add status indicator
+                this.status = this.addWidget("text", "status", "Ready", () => {}, {
+                    serialize: false
+                });
+                this.status.disabled = true;
+                
+                // Update custom prompt visibility based on selection
+                if (this.promptTypeWidget && this.customPromptWidget) {
+                    const originalCallback = this.promptTypeWidget.callback;
+                    this.promptTypeWidget.callback = (value) => {
+                        if (originalCallback) originalCallback.call(this.promptTypeWidget, value);
+                        this.updateCustomPromptVisibility();
+                    };
+                }
+                
+                return result;
+            };
+            
+            // Add method to show help dialog
+            nodeType.prototype.showHelpDialog = function() {
+                const helpContent = `
+                    <div style="padding: 20px; max-width: 600px;">
+                        <h2>Gemini Prompt Engineer Setup</h2>
+                        
+                        <h3>1. Get API Key</h3>
+                        <p>Get your free API key from: <a href="https://makersuite.google.com/app/apikey" target="_blank">Google AI Studio</a></p>
+                        
+                        <h3>2. Set API Key</h3>
+                        <p>Choose one of these methods:</p>
+                        <ul>
+                            <li><strong>Environment Variable:</strong> Set GEMINI_API_KEY in your system</li>
+                            <li><strong>Config File:</strong> Create gemini_config.json in ComfyUI root with {"api_key": "your-key"}</li>
+                            <li><strong>Node Input:</strong> Enter directly in the api_key field</li>
+                        </ul>
+                        
+                        <h3>3. Install Dependencies</h3>
+                        <code>pip install google-generativeai</code>
+                        
+                        <h3>Prompt Types</h3>
+                        <ul>
+                            <li><strong>FLUX:</strong> Detailed artistic prompts with quality markers</li>
+                            <li><strong>SDXL:</strong> Positive/negative prompt pairs with weights</li>
+                            <li><strong>Danbooru:</strong> Anime-style booru tags</li>
+                            <li><strong>Video:</strong> Motion and temporal descriptions</li>
+                        </ul>
+                        
+                        <h3>Gemini Models</h3>
+                        <ul>
+                            <li><strong>gemini-1.5-flash:</strong> Fast and efficient (recommended for most uses)</li>
+                            <li><strong>gemini-1.5-flash-8b:</strong> Smaller and faster, good for simple prompts</li>
+                            <li><strong>gemini-1.5-pro:</strong> Most capable, best quality results</li>
+                            <li><strong>gemini-1.0-pro:</strong> Previous generation, stable option</li>
+                        </ul>
+                        
+                        <h3>Custom Prompts</h3>
+                        <p>You can override any template by entering your own system prompt in the custom_prompt field.</p>
+                    </div>
+                `;
+                
+                app.ui.dialog.show(helpContent);
+            };
+            
+            // Add method to update custom prompt visibility
+            nodeType.prototype.updateCustomPromptVisibility = function() {
+                // You could implement logic here to show/hide custom prompt based on selection
+                // For now, it's always visible but this method provides extensibility
+            };
+            
+            // Override execute to show status
+            const onExecute = nodeType.prototype.onExecute;
+            nodeType.prototype.onExecute = function() {
+                if (this.status) {
+                    this.status.value = "Processing...";
+                }
+                const result = onExecute?.apply(this, arguments);
+                return result;
+            };
+            
+            // Handle execution feedback
+            const onExecuted = nodeType.prototype.onExecuted;
+            nodeType.prototype.onExecuted = function(message) {
+                const result = onExecuted?.apply(this, arguments);
+                
+                if (this.status) {
+                    // Check if there was an error in the output
+                    const outputs = message.output;
+                    if (outputs && outputs.prompt && outputs.prompt[0] && outputs.prompt[0].startsWith("Error:")) {
+                        this.status.value = "Error - Check output";
+                        this.bgcolor = "#552222";
+                    } else {
+                        this.status.value = "Success!";
+                        this.bgcolor = "#225522";
+                    }
+                    
+                    // Reset color after delay
+                    setTimeout(() => {
+                        this.bgcolor = "";
+                        if (this.status) {
+                            this.status.value = "Ready";
+                        }
+                    }, 3000);
+                }
+                
+                return result;
+            };
+        }
+    },
+    
+    // Add custom styling
+    async setup() {
+        const style = document.createElement("style");
+        style.textContent = `
+            .gemini-prompt-help {
+                background: #1a1a1a;
+                border: 1px solid #444;
+                border-radius: 8px;
+                color: #fff;
+            }
+            
+            .gemini-prompt-help h2 {
+                color: #4285f4;
+                margin-top: 0;
+            }
+            
+            .gemini-prompt-help h3 {
+                color: #8ab4f8;
+                margin-top: 20px;
+            }
+            
+            .gemini-prompt-help code {
+                background: #333;
+                padding: 2px 6px;
+                border-radius: 4px;
+                font-family: monospace;
+            }
+            
+            .gemini-prompt-help a {
+                color: #8ab4f8;
+                text-decoration: none;
+            }
+            
+            .gemini-prompt-help a:hover {
+                text-decoration: underline;
+            }
+        `;
+        document.head.appendChild(style);
+    }
+});