feat: Add auto-batching support for large LoRA collections

- Add auto-batching functionality to split large LoRA collections into manageable chunks
- Implement batch_size parameter to control number of LoRAs per batch (default: 25)
- Add batch_index parameter to select which batch to process
- Include batch tracking metadata in LORA_PARAMS for visualization
- Display batch info in plot parameters when available
- Update lora_list output to show batch header when auto-batching is enabled
- Add comprehensive tests for batching functionality
- Update documentation with detailed auto-batching usage instructions

This feature prevents UI disconnection issues when processing large numbers of LoRAs
by allowing users to process them in smaller batches sequentially.

.github/workflows/code-quality.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
 
     - name: Set up Python 3.10
       uses: actions/setup-python@v5
@@ -133,7 +133,7 @@ jobs:
   security:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
 
     - name: Set up Python 3.10
       uses: actions/setup-python@v5
@@ -164,7 +164,7 @@ jobs:
   architecture:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
 
     - name: Set up Python 3.10
       uses: actions/setup-python@v5

.github/workflows/publish.yml

@@ -18,7 +18,7 @@ jobs:
     if: ${{ github.repository_owner == 'ComfyAssets' }}
     steps:
       - name: Check out code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           submodules: true
       - name: Publish Custom Node

.github/workflows/release.yml

@@ -15,7 +15,7 @@ jobs:
       contents: write
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
 
     - name: Set up Python 3.10
       uses: actions/setup-python@v5

.github/workflows/tests.yml

@@ -17,7 +17,7 @@ jobs:
         python-version: [3.8, 3.9, "3.10", "3.11", "3.12"]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
@@ -53,7 +53,7 @@ jobs:
           print('✓ All imports successful')
 
           # Test base node
-          assert ComfyAssetsBaseNode.CATEGORY.startswith('ComfyAssets')
+          assert 'ComfyAssets' in ComfyAssetsBaseNode.CATEGORY
           print('✓ Base node tests passed')
 
           # Test dimension extraction
@@ -168,7 +168,7 @@ jobs:
           assert node.RETURN_TYPES[2] == 'INT'
           assert node.RETURN_TYPES[3] == 'FLOAT'
           assert node.RETURN_NAMES == ('sampler_name', 'scheduler', 'steps', 'cfg')
-          assert node.CATEGORY == 'ComfyAssets/🌀 Samplers'
+          assert node.CATEGORY == '🫶 ComfyAssets/🌀 Samplers'
           print('✓ Sampler Combo return types tests passed')
 
           # Test sampler combo functionality
@@ -217,7 +217,7 @@ jobs:
           # Test return types
           assert node.RETURN_TYPES == ('INT',)
           assert node.RETURN_NAMES == ('seed',)
-          assert node.CATEGORY == 'ComfyAssets/🌱 Seeds'
+          assert node.CATEGORY == '🫶 ComfyAssets/🌱 Seeds'
           print('✓ Seed History return types tests passed')
 
           # Test seed output functionality
@@ -333,7 +333,7 @@ jobs:
 
           assert res_class.RETURN_TYPES == ('INT', 'INT')
           assert res_class.RETURN_NAMES == ('width', 'height')
-          assert res_class.CATEGORY.startswith('ComfyAssets/')
+          assert 'ComfyAssets/' in res_class.CATEGORY
           print('✓ Resolution Calculator ComfyUI integration passed')
 
           # Test Width Height Selector
@@ -354,7 +354,7 @@ jobs:
 
           assert wh_class.RETURN_TYPES == ('INT', 'INT')
           assert wh_class.RETURN_NAMES == ('width', 'height')
-          assert wh_class.CATEGORY.startswith('ComfyAssets/')
+          assert 'ComfyAssets/' in wh_class.CATEGORY
           print('✓ Width Height Selector ComfyUI integration passed')
 
           # Test Sampler Combo
@@ -374,7 +374,7 @@ jobs:
           assert 'steps' in input_types['required']
           assert 'cfg' in input_types['required']
 
-          assert sampler_class.CATEGORY.startswith('ComfyAssets/')
+          assert 'ComfyAssets/' in sampler_class.CATEGORY
           print('✓ Sampler Combo ComfyUI integration passed')
 
           # Test Seed History
@@ -393,7 +393,7 @@ jobs:
 
           assert seed_class.RETURN_TYPES == ('INT',)
           assert seed_class.RETURN_NAMES == ('seed',)
-          assert seed_class.CATEGORY.startswith('ComfyAssets/')
+          assert 'ComfyAssets/' in seed_class.CATEGORY
           print('✓ Seed History ComfyUI integration passed')
 
           print('🎉 All tools ComfyUI integration readiness tests passed!')
@@ -402,7 +402,7 @@ jobs:
   test-package-structure:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Set up Python 3.10
         uses: actions/setup-python@v5
@@ -458,7 +458,7 @@ jobs:
   test-documentation:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Test documentation completeness
         run: |

README.md

@@ -8,7 +8,14 @@
 
 > A modular collection of essential custom ComfyUI nodes missing from the standard release.
 
-ComfyUI-KikoTools provides carefully crafted, production-ready nodes grouped under the **"ComfyAssets"** category. Each tool is designed with clean interfaces, comprehensive testing, and optimized performance for SDXL and FLUX workflows.
+ComfyUI-KikoTools provides carefully crafted, production-ready nodes under the "ComfyAssets" category.
+Each tool is built with clean interfaces, thorough testing, and optimized performance for SDXL and FLUX workflows.
+
+This project started out of frustration with keeping ComfyUI up to date and waiting for dozens of custom nodes to update—most of which I didn’t even use. After taking a hard look at my workflow, I realized I only needed one or two features from these nodes, many of which were abandoned or stuck in maintenance mode.
+
+I tried forking, patching, and submitting merge requests, but eventually decided to create my own curated collection of tools—fully supported and maintained by me. That’s how Kiko’s Tools was born.
+
+I’m sharing them here with the community, and I hope you find them as useful as I do.
 
 ## 🚀 Features
 
@@ -26,6 +33,10 @@ ComfyUI-KikoTools provides carefully crafted, production-ready nodes grouped und
 | [🤖 Gemini Prompt Engineer](#-gemini-prompt-engineer) | AI-powered image analysis and prompt generation | 🧠 Prompts |
 | [🔍 Display Any](#-display-any) | Universal debugging tool for any data type | 👁️ Display |
 | [🖼️ Image to Multiple Of](#️-image-to-multiple-of) | Adjust dimensions to multiples for compatibility | 🖼️ Resolution |
+| [📉 Image Scale Down By](#-image-scale-down-by) | Scale images down by a factor with quality preservation | 🖼️ Resolution |
+| [🎬 Film Grain](#-film-grain) | Add realistic film grain effects to images | 💾 Images |
+| [🔤 Embedding Autocomplete](#-embedding-autocomplete) | Smart autocomplete for embeddings, LoRAs, and tags | 🔧 Utils |
+| [🧹 Kiko Purge VRAM](#-kiko-purge-vram) | Intelligent VRAM management with detailed reporting | 🛠️ Utils |
 
 ### 🧰 xyz-helpers Tools
 
@@ -218,6 +229,41 @@ Adjusts image dimensions to be multiples of a specified value for model compatib
 
 ![Image to Multiple Of Example](examples/workflows/image_to_multiple_of_example.png)
 
+#### 📉 Image Scale Down By
+Efficiently scale images down by a specified factor with quality preservation.
+
+- **Proportional Scaling**: Reduces both width and height by the same factor
+- **Quality Preservation**: Uses bilinear interpolation with antialiasing
+- **Batch Support**: Process multiple images simultaneously
+- **Memory Efficient**: Optimized for large image batches
+- **Flexible Factor**: Scale from 0.01x to 1.0x with 0.01 precision
+
+**Use Cases:**
+- Create thumbnails or preview images
+- Reduce memory usage for large workflows
+- Generate image pyramids for multi-scale processing
+- Quick downsampling for performance optimization
+- Prepare images for web display or transmission
+
+#### 🎬 Film Grain
+Add realistic analog film grain effects to generated images.
+
+- **Realistic Grain Simulation**: Mimics actual film photography characteristics
+- **Grain Size Control**: Fine to coarse grain patterns (0.25x to 2.0x)
+- **Intensity Adjustment**: Variable strength from subtle to pronounced (0-10)
+- **Color Saturation**: Monochrome to full color grain (0-2)
+- **Shadow Lifting (Toe)**: Film-like shadow response curves
+- **Red Multiplier**: Adjust red channel independently for vintage looks
+- **Alpha Preservation**: Maintains transparency when present
+- **ITU-R BT.709 Color Space**: Professional color handling
+
+**Use Cases:**
+- Add vintage film aesthetic to AI-generated images
+- Create cinematic looks with authentic grain patterns
+- Simulate different film stocks (35mm, 16mm, etc.)
+- Add texture to overly smooth AI renders
+- Match grain from reference photography
+
 #### 🎛️ Flux Sampler Params
 FLUX-optimized parameter generator with intelligent batch processing capabilities.
 
@@ -311,6 +357,85 @@ Unified interface for text encoding and sampler parameter management.
 - Quick template-based generation
 - Batch prompt processing
 
+### 🔤 Embedding Autocomplete
+
+**Intelligent autocomplete for embeddings, LoRAs, and custom tags in text prompts.**
+
+<div align="center">
+  <img src="https://github.com/ComfyAssets/ComfyUI-KikoTools/blob/main/examples/ac-emb.png?raw=true" width="30%" alt="Embedding Autocomplete" />
+  <img src="https://github.com/ComfyAssets/ComfyUI-KikoTools/blob/main/examples/ac-lora.png?raw=true" width="30%" alt="LoRA Autocomplete" />
+  <img src="https://github.com/ComfyAssets/ComfyUI-KikoTools/blob/main/examples/ac-tag.png?raw=true" width="30%" alt="Tag Autocomplete" />
+</div>
+
+This feature is an enhanced fork of the autocomplete functionality from [ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) by pythongosssss. We've modernized the codebase, fixed existing bugs, and added robust security features.
+
+**Key Features:**
+- **Smart Triggers**: Type `embedding:` for embeddings, `<lora:` for LoRAs, or just start typing for tags
+- **Custom Word Lists**: Load tag databases (like Danbooru tags) from any URL
+- **Security First**: Comprehensive input validation prevents code injection and XSS attacks
+- **Flexible Settings**: Customize triggers, auto-insert commas, replace underscores, and more
+- **Performance Optimized**: Handles 100,000+ tags smoothly with frequency-based sorting
+- **Visual Polish**: Clean UI with proper scrolling, keyboard navigation, and type indicators
+
+**Settings Include:**
+- Enable/disable autocomplete for embeddings, LoRAs, and custom tags
+- Configurable trigger phrases (e.g., `emb:`, `lora:`, custom shortcuts)
+- Auto-insert comma after completion
+- Replace underscores with spaces in tags
+- Choose insertion keys (Tab, Enter, or both)
+- Load custom word lists from URLs with security validation
+
+**Security Features:**
+- Validates all loaded content to prevent script injection
+- Blocks dangerous patterns (eval, innerHTML, script tags, etc.)
+- Safe character whitelist for tags
+- File size limits to prevent memory exhaustion
+- Clear error messages for rejected content
+
+**Credits:**
+- Original autocomplete concept by [pythongosssss](https://github.com/pythongosssss/ComfyUI-Custom-Scripts)
+- Enhanced and modernized by KikoTools team
+
+### 🧹 Kiko Purge VRAM
+**Intelligent GPU memory management with threshold-based triggering and detailed reporting.**
+
+**Key Features:**
+- **4 Purge Modes**: 
+  - `soft`: Basic garbage collection and cache clearing
+  - `aggressive`: Multiple GC passes with full CUDA cache clearing
+  - `models_only`: Unload all models and clear model cache
+  - `cache_only`: Clear CUDA cache without garbage collection
+- **Smart Thresholds**: Only purge when memory usage exceeds specified MB limit
+- **Detailed Reporting**: Shows before/after memory usage, freed MB, and timing
+- **Passthrough Design**: Acts as workflow checkpoint without disrupting data flow
+- **CPU Fallback**: Gracefully handles non-CUDA environments
+
+**Use Cases:**
+- Free memory between heavy processing stages
+- Prevent OOM errors in complex workflows
+- Debug memory usage patterns
+- Optimize multi-model workflows
+- Clean up after batch processing
+
+**Parameters:**
+- **anything**: Any input (passed through unchanged)
+- **mode**: Purge strategy selection
+- **report_memory**: Generate detailed memory statistics
+- **memory_threshold_mb**: Only purge if usage exceeds (0 = always purge)
+
+**Example Output:**
+```
+Memory usage (5000.0 MB) exceeds threshold (4000 MB)
+
+Memory Purge Report
+-------------------
+Mode: soft
+Memory Freed: 2500.0 MB
+Before: 5000.0 MB used (62.5%)
+After: 2500.0 MB used (31.3%)
+Time: 150.0ms
+```
+
 ### 💾 Kiko Save Image Features
 
 **Use Cases:**
@@ -545,6 +670,8 @@ Example workflow available: [xyz_helpers_lora_testing.json](examples/workflows/x
 | **Gemini Prompt Engineer** | AI-powered image analysis with dynamic model refresh | ✅ Complete | [Docs](examples/documentation/gemini_prompt.md) |
 | **Display Any** | Universal debugging tool for any data type or tensor shapes | ✅ Complete | [Docs](examples/documentation/display_any.md) |
 | **Image to Multiple Of** | Adjust image dimensions to multiples for model compatibility | ✅ Complete | [Docs](examples/documentation/image_to_multiple_of.md) |
+| **Image Scale Down By** | Efficiently scale images down by a specified factor | ✅ Complete | [Docs](examples/documentation/image_scale_down_by.md) |
+| **Film Grain** | Add realistic analog film grain effects to images | ✅ Complete | [Docs](examples/documentation/film_grain.md) |
 | **Flux Sampler Params** | FLUX-optimized parameter generator with batch support | ✅ Complete | [Docs](examples/documentation/flux_sampler_params.md) |
 | **LoRA Folder Batch** | Batch process multiple LoRAs from folders | ✅ Complete | [Docs](examples/documentation/lora_folder_batch.md) |
 | **Plot Parameters** | Visualize parameter effects with graphs | ✅ Complete | [Docs](examples/documentation/plot_parameters.md) |
@@ -844,8 +971,9 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ## 📈 Stats
 
-- **Nodes**: 16 (10 core tools + 6 xyz-helpers)
-- **Categories**: 8 emoji-based categories for better organization
+- **Nodes**: 19 (13 core tools + 6 xyz-helpers)
+- **Features**: Embedding Autocomplete (settings-based, not a node)
+- **Categories**: 9 emoji-based categories for better organization
 - **Format Support**: 3 (PNG, JPEG, WebP with advanced controls)
 - **Presets**: 26 curated resolution presets
 - **Interactive Features**: 8+ (swap buttons, history UI, popup viewers, parameter visualization)

__init__.py

@@ -13,7 +13,91 @@ except ImportError:
     from kikotools import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
 
 # Tell ComfyUI where to find our JavaScript extensions
-WEB_DIRECTORY = "./web"
+import os
+
+WEB_DIRECTORY = os.path.join(os.path.dirname(os.path.abspath(__file__)), "web")
+
+# Import server components at module level to ensure they're available
+try:
+    from aiohttp import web
+    from server import PromptServer
+    import folder_paths
+
+    print("[KikoTools] Server imports successful")
+
+    # Register autocomplete endpoints directly
+    @PromptServer.instance.routes.get("/kikotools/autocomplete/embeddings")
+    async def get_embeddings(request):
+        """API endpoint for getting list of embeddings with full paths."""
+        print("[KikoTools] Embeddings endpoint called")
+        try:
+            embedding_files = folder_paths.get_filename_list("embeddings")
+            print(f"[KikoTools] Found {len(embedding_files)} embedding files")
+            # Return embeddings with their subdirectory paths, without extensions
+            embeddings = []
+            for f in embedding_files:
+                # Remove extension but keep subdirectory path
+                clean_path = os.path.splitext(f)[0]
+                embeddings.append(
+                    {
+                        "file_name": clean_path,
+                        "model_name": clean_path,
+                        "name": os.path.basename(clean_path),
+                        "path": clean_path,
+                    }
+                )
+            if len(embeddings) > 0:
+                print(f"[KikoTools] Sample embedding: {embeddings[0]}")
+            print(f"[KikoTools] Returning {len(embeddings)} embeddings with paths")
+            return web.json_response(embeddings)
+        except Exception as e:
+            print(f"[KikoTools] Error getting embeddings: {e}")
+            import traceback
+
+            traceback.print_exc()
+            return web.json_response([])
+
+    @PromptServer.instance.routes.get("/kikotools/autocomplete/loras")
+    async def get_loras(request):
+        """API endpoint for getting list of LoRAs."""
+        print("[KikoTools] LoRA endpoint called")
+        try:
+            lora_files = folder_paths.get_filename_list("loras")
+            print(f"[KikoTools] Found {len(lora_files)} LoRA files")
+            # Return LoRAs with paths
+            loras = []
+            for f in lora_files:
+                clean_path = os.path.splitext(f)[0]
+                loras.append(
+                    {
+                        "name": os.path.basename(clean_path),
+                        "path": clean_path,
+                        "file": f,
+                    }
+                )
+            print(f"[KikoTools] Returning {len(loras)} LoRAs")
+            return web.json_response(loras)
+        except Exception as e:
+            print(f"[KikoTools] Error getting LoRAs: {e}")
+            import traceback
+
+            traceback.print_exc()
+            return web.json_response([])
+
+    print("[KikoTools] Autocomplete API endpoints registered successfully")
+    print(
+        "[KikoTools] Routes available: /kikotools/autocomplete/embeddings and /kikotools/autocomplete/loras"
+    )
+
+except ImportError as e:
+    print(f"[KikoTools] Could not import server components: {e}")
+except Exception as e:
+    print(f"[KikoTools] Unexpected error setting up API: {e}")
+    import traceback
+
+    traceback.print_exc()
+
+# API endpoints are registered above at module import time
 
 
 def get_version():

examples/documentation/kiko_film_grain.md

@@ -0,0 +1,125 @@
+# Kiko Film Grain
+
+## Overview
+The **Kiko Film Grain** node applies realistic film grain effects to images, simulating the aesthetic of analog film photography. It provides comprehensive controls for grain size, intensity, color saturation, and shadow lifting to achieve various film looks.
+
+## Node Details
+- **Category**: ComfyAssets/image
+- **Node Name**: KikoFilmGrain
+- **Display Name**: Kiko Film Grain
+
+## Inputs
+
+### Required
+- **image** (`IMAGE`)
+  - The input image to apply film grain to
+  - Supports batch processing
+  - Preserves alpha channel if present
+
+### Parameters
+- **scale** (`FLOAT`)
+  - Controls the size of the grain pattern
+  - Range: 0.25 to 2.0
+  - Default: 0.5
+  - Lower values = finer grain, higher values = coarser grain
+
+- **strength** (`FLOAT`)
+  - Intensity of the grain effect
+  - Range: 0.0 to 10.0
+  - Default: 0.5
+  - 0.0 = no grain, higher values = more pronounced grain
+
+- **saturation** (`FLOAT`)
+  - Color saturation of the grain
+  - Range: 0.0 to 2.0
+  - Default: 0.7
+  - 0.0 = monochrome grain, 1.0 = full color, >1.0 = oversaturated
+
+- **toe** (`FLOAT`)
+  - Lifts blacks/shadows for a film-like look
+  - Range: -0.2 to 0.5
+  - Default: 0.0
+  - Positive values lift shadows, negative values crush blacks
+
+- **seed** (`INT`)
+  - Random seed for grain pattern generation
+  - Range: 0 to maximum integer
+  - Default: 0
+  - Use for reproducible grain patterns
+
+## Outputs
+- **image** (`IMAGE`)
+  - The processed image with film grain applied
+  - Same dimensions and batch size as input
+  - Alpha channel preserved if present
+
+## Usage Examples
+
+### Subtle Film Look
+```
+Scale: 0.5
+Strength: 0.3
+Saturation: 0.8
+Toe: 0.05
+```
+Creates a subtle, fine-grained film aesthetic suitable for portraits.
+
+### Vintage Film
+```
+Scale: 1.0
+Strength: 0.8
+Saturation: 0.5
+Toe: 0.15
+```
+Simulates vintage film with moderate grain and lifted shadows.
+
+### High ISO Film
+```
+Scale: 0.75
+Strength: 1.5
+Saturation: 0.6
+Toe: 0.1
+```
+Emulates high ISO film stock with pronounced grain.
+
+### Black & White Film
+```
+Scale: 0.6
+Strength: 0.6
+Saturation: 0.0
+Toe: 0.08
+```
+Creates monochrome grain perfect for black and white photography.
+
+## Technical Details
+
+### Improvements Over Standard Implementations
+1. **Pure PyTorch Operations**: No OpenCV dependencies, better GPU utilization
+2. **ITU-R BT.709 Color Space**: Accurate color conversion for grain application
+3. **Screen Blend Mode**: Preserves highlights better than multiply blending
+4. **Channel-Specific Weighting**: Film grain is stronger in blue channel (3x), moderate in red (2x), matching real film characteristics
+5. **Efficient Memory Management**: Minimizes tensor copies and conversions
+
+### Algorithm Overview
+1. Generate random noise at specified scale
+2. Convert to YCbCr color space for realistic grain distribution
+3. Apply different blur kernels to each channel:
+   - Y (luminance): 3x3 kernel for fine detail
+   - Cb (blue-yellow): 15x15 kernel for color noise
+   - Cr (red-green): 11x11 kernel for color noise
+4. Convert back to RGB and apply strength/saturation
+5. Use screen blend mode to combine with original image
+6. Apply toe adjustment for film-like shadow response
+
+## Tips
+- Start with low strength values (0.2-0.5) and adjust upward
+- For color images, saturation between 0.5-0.8 looks most natural
+- Combine with color grading nodes for complete film emulation
+- Use consistent seed values across batch for uniform grain
+- Scale parameter affects both grain size and render performance (smaller scale = more computation)
+
+## Compatibility
+- Works with any image format supported by ComfyUI
+- Preserves image properties (alpha channel, batch size)
+- Compatible with both RGB and RGBA images
+- Efficient batch processing support

examples/documentation/lora_folder_batch.md

@@ -13,6 +13,7 @@ This node is based on work from [comfyui-essentials-nodes](https://github.com/cu
 - **Flexible Strength Control**: Single, multiple, or range-based strength values
 - **Batch Modes**: Sequential or combinatorial strength application
 - **Epoch Detection**: Automatically extracts epoch numbers from filenames
+- **Auto-Batching**: Automatically splits large LoRA collections into manageable chunks to prevent UI disconnection
 
 ## Node Properties
 - **Category**: `ComfyAssets/🧰 xyz-helpers`
@@ -33,6 +34,11 @@ This node is based on work from [comfyui-essentials-nodes](https://github.com/cu
 |-----------|------|---------|-------------|
 | `include_pattern` | STRING | "" | Regex pattern to include files |
 | `exclude_pattern` | STRING | "" | Regex pattern to exclude files |
+| `max_loras` | INT | 50 | Maximum LoRAs to process (when auto_batch disabled) |
+| `sort_order` | DROPDOWN | natural | Sorting method [natural, alphabetical, newest, oldest] |
+| `auto_batch` | DROPDOWN | disabled | Enable auto-batching for large collections [disabled, enabled] |
+| `batch_size` | INT | 25 | Number of LoRAs per batch when auto-batching |
+| `batch_index` | INT | 0 | Which batch to output (0-based) when auto-batching |
 
 ### Strength Format Options
 - **Single**: `"1.0"` - Apply same strength to all LoRAs
@@ -72,6 +78,16 @@ LoRAFolderBatch → Processing Pipeline
     strength: "0.8...1.2+0.1"
 ```
 
+### Auto-Batch Large Collections
+```
+LoRAFolderBatch → FluxSamplerParams → KSampler
+    folder_path: "massive_lora_collection"  # 100+ files
+    strength: "1.0"
+    auto_batch: enabled
+    batch_size: 25
+    batch_index: 0  # Change to 1, 2, 3... for subsequent batches
+```
+
 ## Batch Modes Explained
 
 ### Sequential Mode
@@ -86,6 +102,41 @@ Each LoRA is tested with ALL strength values:
 - LoRA2 → [0.5, 0.75, 1.0]
 - LoRA3 → [0.5, 0.75, 1.0]
 
+## Auto-Batching for Large Collections
+
+### Overview
+When testing large numbers of LoRAs (e.g., 75+ files), ComfyUI can experience UI disconnections or memory issues. Auto-batching solves this by automatically splitting your LoRA collection into smaller, manageable chunks.
+
+### How It Works
+1. **Enable Auto-Batching**: Set `auto_batch` to "enabled"
+2. **Set Batch Size**: Configure `batch_size` (default: 25, range: 5-100)
+3. **Select Batch**: Use `batch_index` to choose which batch to process
+
+### Example: Testing 75 LoRAs
+With 75 LoRAs and batch_size=25, the system creates 3 batches:
+- **Batch 0**: LoRAs 1-25 (set batch_index=0)
+- **Batch 1**: LoRAs 26-50 (set batch_index=1)
+- **Batch 2**: LoRAs 51-75 (set batch_index=2)
+
+Run your workflow 3 times, changing only the `batch_index` each time.
+
+### Visual Feedback
+When auto-batching is enabled, the `lora_list` output includes batch information:
+```
+=== Batch 1/3 (LoRAs 1-25) ===
+
+style-epoch-001
+style-epoch-002
+...
+```
+
+### Best Practices for Auto-Batching
+1. **Start with Default**: Use batch_size=25 for most scenarios
+2. **Adjust for Memory**: Decrease batch_size if you still experience issues
+3. **Combinatorial Mode**: Be extra careful - 25 LoRAs × 3 strengths = 75 combinations
+4. **Save Between Batches**: Save your results after each batch to avoid data loss
+5. **Use Plot Parameters**: The batch info appears in plot visualizations for easy tracking
+
 ## File Naming Patterns
 
 ### Supported Epoch Formats
@@ -207,6 +258,7 @@ batch_mode: sequential
 - **1.0.1**: Added natural sorting for epochs
 - **1.0.2**: Enhanced pattern filtering
 - **1.0.3**: Improved batch modes and strength parsing
+- **1.0.4**: Added auto-batching for large LoRA collections
 
 ## Credits
 Original implementation by cubiq in [comfyui-essentials-nodes](https://github.com/cubiq/ComfyUI_essentials). Adapted and maintained by the ComfyAssets team.

examples/workflows/kiko_film_grain_example.json

@@ -0,0 +1,165 @@
+{
+  "id": "kiko-film-grain-example",
+  "revision": 0,
+  "last_node_id": 4,
+  "last_link_id": 2,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "LoadImage",
+      "pos": [
+        50,
+        100
+      ],
+      "size": [
+        350,
+        450
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [1],
+          "shape": 3,
+          "label": "IMAGE"
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3,
+          "label": "MASK"
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "example.png"
+      ]
+    },
+    {
+      "id": 2,
+      "type": "KikoFilmGrain",
+      "pos": [
+        450,
+        100
+      ],
+      "size": [
+        315,
+        202
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "links": [2],
+          "shape": 3,
+          "label": "image",
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "cnr_id": "kikotools",
+        "Node name for S&R": "KikoFilmGrain"
+      },
+      "widgets_values": [
+        0.5,
+        0.5,
+        0.7,
+        0.0,
+        0
+      ],
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 3,
+      "type": "PreviewImage",
+      "pos": [
+        850,
+        100
+      ],
+      "size": [
+        350,
+        450
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 4,
+      "type": "Note",
+      "pos": [
+        450,
+        350
+      ],
+      "size": [
+        315,
+        150
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "properties": {
+        "text": ""
+      },
+      "widgets_values": [
+        "Kiko Film Grain Example\n\nThis workflow demonstrates the film grain effect.\n\nAdjust parameters:\n- Scale: Grain size (0.25-2.0)\n- Strength: Intensity (0.0-10.0)\n- Saturation: Color amount (0.0-2.0)\n- Toe: Shadow lifting (-0.2-0.5)\n- Seed: Random pattern"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    }
+  ],
+  "links": [
+    [
+      1,
+      1,
+      0,
+      2,
+      0,
+      "IMAGE"
+    ],
+    [
+      2,
+      2,
+      0,
+      3,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 1.0,
+      "offset": [0, 0]
+    }
+  },
+  "version": 0.4
+}

kikotools/__init__.py

@@ -3,24 +3,27 @@ KikoTools package initialization and node registry
 Handles automatic discovery and registration of all ComfyAssets tools
 """
 
-from .tools.resolution_calculator import ResolutionCalculatorNode
-from .tools.width_height_selector import WidthHeightSelectorNode
-from .tools.seed_history import SeedHistoryNode
-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.image_scale_down_by import ImageScaleDownByNode
-from .tools.gemini_prompt import GeminiPromptNode
 from .tools.display_any import DisplayAnyNode
 from .tools.display_text import DisplayTextNode
+from .tools.embedding_autocomplete import KikoEmbeddingAutocomplete
+from .tools.empty_latent_batch import EmptyLatentBatchNode
+from .tools.gemini_prompt import GeminiPromptNode
+from .tools.image_scale_down_by import ImageScaleDownByNode
+from .tools.image_to_multiple_of import ImageToMultipleOfNode
+from .tools.kiko_film_grain import KikoFilmGrainNode
+from .tools.kiko_purge_vram import KikoPurgeVRAM
+from .tools.kiko_save_image import KikoSaveImageNode
+from .tools.resolution_calculator import ResolutionCalculatorNode
+from .tools.sampler_combo import SamplerComboCompactNode, SamplerComboNode
+from .tools.seed_history import SeedHistoryNode
+from .tools.width_height_selector import WidthHeightSelectorNode
 from .tools.xyz_helpers import (
+    FluxSamplerParamsNode,
+    LoRAFolderBatchNode,
+    PlotParametersNode,
     SamplerSelectHelperNode,
     SchedulerSelectHelperNode,
     TextEncodeSamplerParamsNode,
-    FluxSamplerParamsNode,
-    PlotParametersNode,
-    LoRAFolderBatchNode,
 )
 
 # ComfyUI node registration mappings
@@ -37,12 +40,16 @@ NODE_CLASS_MAPPINGS = {
     "GeminiPrompt": GeminiPromptNode,
     "DisplayAny": DisplayAnyNode,
     "DisplayText": DisplayTextNode,
+    "KikoFilmGrain": KikoFilmGrainNode,
+    "KikoPurgeVRAM": KikoPurgeVRAM,
     "SamplerSelectHelper": SamplerSelectHelperNode,
     "SchedulerSelectHelper": SchedulerSelectHelperNode,
     "TextEncodeSamplerParams": TextEncodeSamplerParamsNode,
     "FluxSamplerParams": FluxSamplerParamsNode,
     "PlotParameters+": PlotParametersNode,
     "LoRAFolderBatch": LoRAFolderBatchNode,
+    # Note: KikoEmbeddingAutocomplete is not registered as a node
+    # It's a settings-only feature accessed through ComfyUI settings menu
 }
 
 NODE_DISPLAY_NAME_MAPPINGS = {
@@ -58,12 +65,15 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "GeminiPrompt": "Gemini Prompt Engineer",
     "DisplayAny": "Display Any",
     "DisplayText": "Display Text",
+    "KikoFilmGrain": "Film Grain",
+    "KikoPurgeVRAM": "Kiko Purge VRAM",
     "SamplerSelectHelper": "Sampler Select Helper",
     "SchedulerSelectHelper": "Scheduler Select Helper",
     "TextEncodeSamplerParams": "Text Encode for Sampler Params",
     "FluxSamplerParams": "Flux Sampler Parameters",
     "PlotParameters+": "Plot Parameters",
     "LoRAFolderBatch": "LoRA Folder Batch",
+    # KikoEmbeddingAutocomplete removed - settings only, not a node
 }
 
 __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

kikotools/base/any_type.py

@@ -0,0 +1,8 @@
+"""AnyType for wildcard input matching in ComfyUI nodes."""
+
+
+class AnyType(str):
+    """A special type that matches any input type in ComfyUI."""
+
+    def __ne__(self, other):
+        return False

kikotools/base/base_node.py

@@ -20,7 +20,7 @@ class ComfyAssetsBaseNode:
     - Consistent return type handling
     """
 
-    CATEGORY = "ComfyAssets"
+    CATEGORY = "🫶 ComfyAssets"
 
     def validate_inputs(self, **kwargs) -> None:
         """

kikotools/core/registry.py

@@ -0,0 +1,96 @@
+"""Tool registry for KikoTools.
+
+This module provides the central registration system for all KikoTools nodes.
+"""
+
+import importlib
+import os
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+
+
+class ToolRegistry:
+    """Central registry for all KikoTools."""
+
+    def __init__(self):
+        self.tools: Dict[str, Any] = {}
+        self.node_classes: Dict[str, Any] = {}
+
+    def register_tool(self, tool_name: str, node_class: Any) -> None:
+        """Register a tool and its node class.
+
+        Args:
+            tool_name: Name of the tool
+            node_class: The ComfyUI node class
+        """
+        self.tools[tool_name] = node_class
+
+        # Also register by class name for ComfyUI
+        class_name = node_class.__name__
+        self.node_classes[class_name] = node_class
+
+    def discover_tools(self) -> None:
+        """Automatically discover and load all tools in the tools directory."""
+        tools_dir = Path(__file__).parent.parent / "tools"
+
+        if not tools_dir.exists():
+            return
+
+        for tool_dir in tools_dir.iterdir():
+            if tool_dir.is_dir() and not tool_dir.name.startswith("_"):
+                self._load_tool(tool_dir.name)
+
+    def _load_tool(self, tool_name: str) -> None:
+        """Load a single tool module.
+
+        Args:
+            tool_name: Name of the tool directory
+        """
+        try:
+            # Try to import the tool's node module
+            module = importlib.import_module(f"kikotools.tools.{tool_name}.node")
+
+            # Look for node classes (classes with ComfyUI node attributes)
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if (
+                    isinstance(attr, type)
+                    and hasattr(attr, "INPUT_TYPES")
+                    and hasattr(attr, "FUNCTION")
+                ):
+                    self.register_tool(tool_name, attr)
+
+                    # If the tool has settings, register them
+                    if hasattr(attr, "SETTINGS"):
+                        from .settings import settings_registry
+
+                        settings_registry.register_tool_settings(
+                            tool_name,
+                            getattr(
+                                attr,
+                                "DISPLAY_NAME",
+                                tool_name.replace("_", " ").title(),
+                            ),
+                            attr.SETTINGS,
+                        )
+
+        except ImportError as e:
+            # Tool might not have a node.py file yet
+            pass
+
+    def get_node_class_mappings(self) -> Dict[str, Any]:
+        """Get node class mappings for ComfyUI registration."""
+        return self.node_classes.copy()
+
+    def get_node_display_name_mappings(self) -> Dict[str, str]:
+        """Get display name mappings for ComfyUI."""
+        mappings = {}
+        for class_name, node_class in self.node_classes.items():
+            if hasattr(node_class, "DISPLAY_NAME"):
+                mappings[class_name] = node_class.DISPLAY_NAME
+            else:
+                # Generate a display name from class name
+                mappings[class_name] = class_name.replace("Kiko", "").replace(
+                    "Node", ""
+                )
+        return mappings

kikotools/core/settings.py

@@ -0,0 +1,201 @@
+"""Settings registry for KikoTools.
+
+This module provides a centralized settings management system for all KikoTools.
+Tools can register their settings, which are then exposed in ComfyUI's settings UI.
+"""
+
+import json
+import os
+from typing import Dict, Any, List, Optional, Union
+from dataclasses import dataclass, field
+
+
+@dataclass
+class SettingDefinition:
+    """Definition of a single setting."""
+
+    id: str
+    name: str
+    type: str  # "boolean", "combo", "number", "string", "custom"
+    default: Any
+    description: Optional[str] = None
+    options: Optional[Union[List[Any], Dict[str, Any]]] = None
+    min_value: Optional[float] = None
+    max_value: Optional[float] = None
+    step: Optional[float] = None
+    on_change: Optional[str] = None  # JavaScript callback as string
+
+
+@dataclass
+class ToolSettings:
+    """Settings collection for a single tool."""
+
+    tool_name: str
+    display_name: str
+    settings: List[SettingDefinition] = field(default_factory=list)
+
+
+class SettingsRegistry:
+    """Central registry for all KikoTools settings."""
+
+    def __init__(self):
+        self.tools: Dict[str, ToolSettings] = {}
+        self.settings_by_id: Dict[str, SettingDefinition] = {}
+
+    def register_tool_settings(
+        self, tool_name: str, display_name: str, settings: Dict[str, Dict[str, Any]]
+    ) -> None:
+        """Register settings for a tool.
+
+        Args:
+            tool_name: Internal tool identifier (e.g., "embedding_autocomplete")
+            display_name: Display name for the tool (e.g., "Embedding Autocomplete")
+            settings: Dictionary of setting configurations
+                {
+                    "enabled": {
+                        "type": "boolean",
+                        "default": True,
+                        "description": "Enable embedding autocomplete"
+                    },
+                    "max_suggestions": {
+                        "type": "combo",
+                        "default": 20,
+                        "options": [10, 20, 50],
+                        "description": "Maximum number of suggestions"
+                    }
+                }
+        """
+        tool_settings = ToolSettings(tool_name, display_name)
+
+        for setting_key, config in settings.items():
+            # Generate fully qualified setting ID
+            setting_id = f"kikotools.{tool_name}.{setting_key}"
+
+            # Create display name with branding
+            setting_name = f"🫶 {display_name}: {setting_key.replace('_', ' ').title()}"
+
+            setting_def = SettingDefinition(
+                id=setting_id,
+                name=setting_name,
+                type=config.get("type", "string"),
+                default=config.get("default"),
+                description=config.get("description"),
+                options=config.get("options"),
+                min_value=config.get("min"),
+                max_value=config.get("max"),
+                step=config.get("step"),
+                on_change=config.get("on_change"),
+            )
+
+            tool_settings.settings.append(setting_def)
+            self.settings_by_id[setting_id] = setting_def
+
+        self.tools[tool_name] = tool_settings
+
+    def get_setting(self, setting_id: str) -> Optional[SettingDefinition]:
+        """Get a setting definition by ID."""
+        return self.settings_by_id.get(setting_id)
+
+    def get_tool_settings(self, tool_name: str) -> Optional[ToolSettings]:
+        """Get all settings for a tool."""
+        return self.tools.get(tool_name)
+
+    def generate_frontend_registration(self) -> str:
+        """Generate JavaScript code for frontend settings registration."""
+        js_lines = [
+            "// Auto-generated KikoTools settings registration",
+            "// This file is automatically generated by the settings registry",
+            "",
+            "import { app } from '../../scripts/app.js';",
+            "",
+            "app.registerExtension({",
+            "    name: 'kikotools.settings',",
+            "    async init() {",
+            "        // Register all KikoTools settings",
+        ]
+
+        for tool_name, tool_settings in self.tools.items():
+            js_lines.append(f"        // {tool_settings.display_name} settings")
+
+            for setting in tool_settings.settings:
+                js_lines.append(f"        app.ui.settings.addSetting({{")
+                js_lines.append(f'            id: "{setting.id}",')
+                js_lines.append(f'            name: "{setting.name}",')
+                js_lines.append(
+                    f"            defaultValue: {self._js_value(setting.default)},"
+                )
+                js_lines.append(f'            type: "{setting.type}",')
+
+                if setting.description:
+                    js_lines.append(f'            tooltip: "{setting.description}",')
+
+                if setting.type == "combo" and setting.options:
+                    js_lines.append(f"            options: (value) => {{")
+                    js_lines.append(
+                        f"                const options = {json.dumps(setting.options)};"
+                    )
+                    js_lines.append(f"                return options.map(opt => ({{")
+                    js_lines.append(f"                    value: opt,")
+                    js_lines.append(f"                    text: String(opt),")
+                    js_lines.append(f"                    selected: opt === value")
+                    js_lines.append(f"                }}));")
+                    js_lines.append(f"            }},")
+
+                if setting.type == "number":
+                    if setting.min_value is not None:
+                        js_lines.append(f"            min: {setting.min_value},")
+                    if setting.max_value is not None:
+                        js_lines.append(f"            max: {setting.max_value},")
+                    if setting.step is not None:
+                        js_lines.append(f"            step: {setting.step},")
+
+                if setting.on_change:
+                    js_lines.append(f"            onChange(value) {{")
+                    js_lines.append(f"                {setting.on_change}")
+                    js_lines.append(f"            }}")
+
+                js_lines.append(f"        }});")
+                js_lines.append("")
+
+        js_lines.extend(["    }", "});", ""])
+
+        return "\n".join(js_lines)
+
+    def _js_value(self, value: Any) -> str:
+        """Convert Python value to JavaScript literal."""
+        if isinstance(value, bool):
+            return "true" if value else "false"
+        elif isinstance(value, str):
+            return f'"{value}"'
+        elif value is None:
+            return "null"
+        else:
+            return str(value)
+
+    def save_frontend_settings(
+        self, output_path: str = "web/js/kikoSettings.js"
+    ) -> None:
+        """Save the generated frontend settings to a file."""
+        js_content = self.generate_frontend_registration()
+
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        with open(output_path, "w") as f:
+            f.write(js_content)
+
+    def get_all_settings(self) -> Dict[str, Any]:
+        """Get all registered settings as a dictionary."""
+        result = {}
+        for tool_name, tool_settings in self.tools.items():
+            result[tool_name] = {
+                "display_name": tool_settings.display_name,
+                "settings": {
+                    setting.id.split(".")[-1]: {
+                        "type": setting.type,
+                        "default": setting.default,
+                        "description": setting.description,
+                        "options": setting.options,
+                    }
+                    for setting in tool_settings.settings
+                },
+            }
+        return result

kikotools/tools/display_any/node.py

@@ -38,7 +38,7 @@ class DisplayAnyNode(ComfyAssetsBaseNode):
         return True
 
     RETURN_TYPES = ("STRING",)
-    CATEGORY = "ComfyAssets/👁️ Display"
+    CATEGORY = "🫶 ComfyAssets/👁️ Display"
     RETURN_NAMES = ("display_text",)
     FUNCTION = "display"
     OUTPUT_NODE = True  # This node displays output in the UI

kikotools/tools/display_text/node.py

@@ -19,7 +19,7 @@ class DisplayTextNode(ComfyAssetsBaseNode):
     RETURN_NAMES = ("text",)
     OUTPUT_NODE = True
     FUNCTION = "display_text"
-    CATEGORY = "ComfyAssets/👁️ Display"
+    CATEGORY = "🫶 ComfyAssets/👁️ Display"
 
     DESCRIPTION = """
 Displays text in the UI with a copy-to-clipboard feature.

kikotools/tools/embedding_autocomplete/__init__.py

@@ -0,0 +1,5 @@
+"""Embedding Autocomplete tool for KikoTools."""
+
+from .node import KikoEmbeddingAutocomplete
+
+__all__ = ["KikoEmbeddingAutocomplete"]

kikotools/tools/embedding_autocomplete/node.py

@@ -0,0 +1,291 @@
+"""KikoEmbeddingAutocomplete node for ComfyUI.
+
+Provides autocomplete functionality for embeddings and LoRAs in text inputs.
+"""
+
+import os
+from typing import Dict, List, Any
+
+try:
+    import folder_paths
+except ImportError:
+    # For testing outside ComfyUI environment
+    folder_paths = None
+
+
+class KikoEmbeddingAutocomplete:
+    """Node that provides embedding autocomplete functionality."""
+
+    DISPLAY_NAME = "🫶 Embedding Autocomplete Settings"
+    CATEGORY = "🫶 ComfyAssets"
+
+    # Settings definition for the settings registry
+    SETTINGS = {
+        "enabled": {
+            "type": "boolean",
+            "default": True,
+            "description": "Enable autocomplete",
+        },
+        "show_embeddings": {
+            "type": "boolean",
+            "default": True,
+            "description": "Show embeddings in autocomplete",
+        },
+        "show_loras": {
+            "type": "boolean",
+            "default": True,
+            "description": "Show LoRAs in autocomplete",
+        },
+        "embedding_trigger": {
+            "type": "text",
+            "default": "embedding:",
+            "description": "Trigger text for embeddings (e.g., 'embedding:', 'emb:', or custom)",
+        },
+        "lora_trigger": {
+            "type": "text",
+            "default": "<lora:",
+            "description": "Trigger text for LoRAs (e.g., '<lora:', 'lora:', or custom)",
+        },
+        "quick_trigger": {
+            "type": "text",
+            "default": "em",
+            "description": "Quick trigger to show embeddings (e.g., 'em', 'emb', or disabled with '')",
+        },
+        "min_chars": {
+            "type": "combo",
+            "default": 2,
+            "options": [1, 2, 3, 4, 5],
+            "description": "Minimum characters before showing suggestions",
+        },
+        "max_suggestions": {
+            "type": "combo",
+            "default": 20,
+            "options": [5, 10, 15, 20, 30, 50, 100],
+            "description": "Maximum number of suggestions to display",
+        },
+        "sort_by_directory": {
+            "type": "boolean",
+            "default": True,
+            "description": "Group suggestions by directory",
+        },
+    }
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        """Define input types for the node."""
+        return {
+            "required": {},
+            "hidden": {
+                "unique_id": "UNIQUE_ID",
+            },
+        }
+
+    RETURN_TYPES = ()
+    RETURN_NAMES = ()
+    FUNCTION = "update_settings"
+    OUTPUT_NODE = True
+
+    @classmethod
+    def VALIDATE_INPUTS(cls, **kwargs):
+        return True
+
+    def __init__(self):
+        self.embeddings_cache = None
+        self.loras_cache = None
+
+    def update_settings(self, unique_id=None):
+        """Update settings display.
+
+        This node serves as a settings indicator.
+        Actual settings are configured in ComfyUI Settings menu.
+        """
+        # This node doesn't actually process anything
+        # It's just a visual indicator that autocomplete is available
+        return ()
+
+    def refresh_cache(self):
+        """Refresh the cache of embeddings and LoRAs."""
+        print("[KikoEmbeddingAutocomplete] Refreshing cache...")
+        self.embeddings_cache = self.get_embeddings()
+        self.loras_cache = self.get_loras()
+        print(
+            f"[KikoEmbeddingAutocomplete] Cached {len(self.embeddings_cache)} embeddings, {len(self.loras_cache)} LoRAs"
+        )
+
+    def get_embeddings(self) -> List[Dict[str, Any]]:
+        """Get list of available embeddings."""
+        embeddings = []
+
+        # Get embedding files from ComfyUI's folder system
+        try:
+            print("[KikoEmbeddingAutocomplete] Getting embeddings list...")
+            if folder_paths is None:
+                return embeddings
+            embedding_files = folder_paths.get_filename_list("embeddings")
+            print(
+                f"[KikoEmbeddingAutocomplete] Found {len(embedding_files)} embedding files"
+            )
+            for file in embedding_files:
+                name = os.path.splitext(file)[0]
+                embeddings.append(
+                    {
+                        "name": name,
+                        "file": file,
+                        "type": "embedding",
+                        "display": f"embedding:{name}",
+                        "value": f"embedding:{name}",
+                    }
+                )
+        except Exception as e:
+            print(f"Error loading embeddings: {e}")
+
+        return embeddings
+
+    def get_loras(self) -> List[Dict[str, Any]]:
+        """Get list of available LoRAs."""
+        loras = []
+
+        # Get LoRA files from ComfyUI's folder system
+        try:
+            if folder_paths is None:
+                return loras
+            lora_files = folder_paths.get_filename_list("loras")
+            for file in lora_files:
+                name = os.path.splitext(file)[0]
+                loras.append(
+                    {
+                        "name": name,
+                        "file": file,
+                        "type": "lora",
+                        "display": f"<lora:{name}:1.0>",
+                        "value": f"<lora:{name}:1.0>",
+                    }
+                )
+        except Exception as e:
+            print(f"Error loading LoRAs: {e}")
+
+        return loras
+
+    @classmethod
+    def IS_CHANGED(cls, **kwargs):
+        """Check if the node needs to be re-executed."""
+        # Always re-execute if refresh is True
+        if kwargs.get("refresh", False):
+            return float("NaN")
+
+        # Check if embeddings/loras folders have changed
+        try:
+            if folder_paths is None:
+                return 0
+            embeddings_path = folder_paths.get_folder_paths("embeddings")[0]
+            loras_path = folder_paths.get_folder_paths("loras")[0]
+
+            # Return combined modification time
+            return os.path.getmtime(embeddings_path) + os.path.getmtime(loras_path)
+        except Exception:
+            return 0
+
+
+class KikoEmbeddingAutocompleteAPI:
+    """API endpoints for embedding autocomplete."""
+
+    @staticmethod
+    def get_suggestions(
+        prefix: str,
+        max_results: int = 20,
+        include_embeddings: bool = True,
+        include_loras: bool = True,
+        case_sensitive: bool = False,
+    ) -> List[Dict[str, Any]]:
+        """Get autocomplete suggestions for a given prefix.
+
+        Args:
+            prefix: The text prefix to match
+            max_results: Maximum number of results to return
+            include_embeddings: Include embeddings in results
+            include_loras: Include LoRAs in results
+            case_sensitive: Use case-sensitive matching
+
+        Returns:
+            List of suggestion dictionaries
+        """
+        suggestions = []
+
+        # Normalize prefix for matching
+        match_prefix = prefix if case_sensitive else prefix.lower()
+
+        # Get embeddings
+        if include_embeddings:
+            try:
+                if folder_paths is None:
+                    embedding_files = []
+                else:
+                    embedding_files = folder_paths.get_filename_list("embeddings")
+                for file in embedding_files:
+                    name = os.path.splitext(file)[0]
+                    match_name = name if case_sensitive else name.lower()
+
+                    # Check for match
+                    if match_name.startswith(match_prefix):
+                        suggestions.append(
+                            {
+                                "name": name,
+                                "type": "embedding",
+                                "display": f"embedding:{name}",
+                                "value": f"embedding:{name}",
+                                "priority": 1 if match_name == match_prefix else 0,
+                            }
+                        )
+                    elif match_prefix in match_name:
+                        suggestions.append(
+                            {
+                                "name": name,
+                                "type": "embedding",
+                                "display": f"embedding:{name}",
+                                "value": f"embedding:{name}",
+                                "priority": -1,
+                            }
+                        )
+            except Exception as e:
+                print(f"Error loading embeddings: {e}")
+
+        # Get LoRAs
+        if include_loras:
+            try:
+                if folder_paths is None:
+                    lora_files = []
+                else:
+                    lora_files = folder_paths.get_filename_list("loras")
+                for file in lora_files:
+                    name = os.path.splitext(file)[0]
+                    match_name = name if case_sensitive else name.lower()
+
+                    # Check for match
+                    if match_name.startswith(match_prefix):
+                        suggestions.append(
+                            {
+                                "name": name,
+                                "type": "lora",
+                                "display": f"<lora:{name}:1.0>",
+                                "value": f"<lora:{name}:1.0>",
+                                "priority": 1 if match_name == match_prefix else 0,
+                            }
+                        )
+                    elif match_prefix in match_name:
+                        suggestions.append(
+                            {
+                                "name": name,
+                                "type": "lora",
+                                "display": f"<lora:{name}:1.0>",
+                                "value": f"<lora:{name}:1.0>",
+                                "priority": -1,
+                            }
+                        )
+            except Exception as e:
+                print(f"Error loading LoRAs: {e}")
+
+        # Sort by priority and name
+        suggestions.sort(key=lambda x: (-x["priority"], x["name"]))
+
+        # Limit results
+        return suggestions[:max_results]

kikotools/tools/empty_latent_batch/node.py

@@ -96,7 +96,7 @@ class EmptyLatentBatchNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("LATENT", "INT", "INT")
     RETURN_NAMES = ("latent", "width", "height")
     FUNCTION = "create_empty_latent"
-    CATEGORY = "ComfyAssets/📦 Latents"
+    CATEGORY = "🫶 ComfyAssets/📦 Latents"
 
     def create_empty_latent(
         self, preset: str, width: int, height: int, batch_size: int

kikotools/tools/gemini_prompt/node.py

@@ -51,7 +51,7 @@ class GeminiPromptNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("STRING", "STRING")
     RETURN_NAMES = ("prompt", "negative_prompt")
     FUNCTION = "generate_prompt"
-    CATEGORY = "ComfyAssets/🧠 Prompts"
+    CATEGORY = "🫶 ComfyAssets/🧠 Prompts"
 
     DESCRIPTION = """
 Analyzes images using Google's Gemini AI to generate optimized prompts.

kikotools/tools/image_scale_down_by/node.py

@@ -35,7 +35,7 @@ class ImageScaleDownByNode(ComfyAssetsBaseNode):
         }
 
     RETURN_TYPES = ("IMAGE",)
-    CATEGORY = "ComfyAssets/🖼️ Resolution"
+    CATEGORY = "🫶 ComfyAssets/🖼️ Resolution"
     RETURN_NAMES = ("images",)
     FUNCTION = "scale_down"
 

kikotools/tools/image_to_multiple_of/node.py

@@ -36,7 +36,7 @@ class ImageToMultipleOfNode(ComfyAssetsBaseNode):
         }
 
     RETURN_TYPES = ("IMAGE",)
-    CATEGORY = "ComfyAssets/🖼️ Resolution"
+    CATEGORY = "🫶 ComfyAssets/🖼️ Resolution"
     RETURN_NAMES = ("image",)
     FUNCTION = "process"
 

kikotools/tools/kiko_film_grain/__init__.py

@@ -0,0 +1,3 @@
+from .node import KikoFilmGrainNode
+
+__all__ = ["KikoFilmGrainNode"]

kikotools/tools/kiko_film_grain/logic.py

@@ -0,0 +1,221 @@
+import torch
+import torch.nn.functional as F
+
+
+def rgb_to_ycbcr(rgb: torch.Tensor) -> torch.Tensor:
+    """
+    Convert RGB tensor to YCbCr color space.
+
+    Args:
+        rgb: Tensor of shape [B, H, W, C] in range [0, 1]
+
+    Returns:
+        YCbCr tensor of same shape
+    """
+    ycbcr = rgb.detach().clone()
+    r, g, b = rgb[:, :, :, 0], rgb[:, :, :, 1], rgb[:, :, :, 2]
+
+    # ITU-R BT.709 coefficients
+    ycbcr[:, :, :, 0] = 0.2126 * r + 0.7152 * g + 0.0722 * b  # Y
+    ycbcr[:, :, :, 1] = -0.1146 * r - 0.3854 * g + 0.5 * b  # Cb
+    ycbcr[:, :, :, 2] = 0.5 * r - 0.4542 * g - 0.0458 * b  # Cr
+
+    return ycbcr
+
+
+def ycbcr_to_rgb(ycbcr: torch.Tensor) -> torch.Tensor:
+    """
+    Convert YCbCr tensor to RGB color space.
+
+    Args:
+        ycbcr: Tensor of shape [B, H, W, C]
+
+    Returns:
+        RGB tensor of same shape in range [0, 1]
+    """
+    rgb = ycbcr.detach().clone()
+    y, cb, cr = ycbcr[:, :, :, 0], ycbcr[:, :, :, 1], ycbcr[:, :, :, 2]
+
+    rgb[:, :, :, 0] = y + 1.5748 * cr  # R
+    rgb[:, :, :, 1] = y - 0.1873 * cb - 0.4681 * cr  # G
+    rgb[:, :, :, 2] = y + 1.8556 * cb  # B
+
+    return torch.clamp(rgb, 0, 1)
+
+
+def apply_gaussian_blur(tensor: torch.Tensor, kernel_size: int) -> torch.Tensor:
+    """
+    Apply Gaussian blur to a tensor using PyTorch operations.
+
+    Args:
+        tensor: Tensor of shape [B, H, W, C]
+        kernel_size: Size of the Gaussian kernel (must be odd)
+
+    Returns:
+        Blurred tensor of same shape
+    """
+    if kernel_size <= 1:
+        return tensor
+
+    # Ensure kernel size is odd
+    kernel_size = kernel_size if kernel_size % 2 == 1 else kernel_size + 1
+
+    # Create Gaussian kernel
+    sigma = kernel_size / 3.0
+    x = torch.arange(kernel_size, dtype=torch.float32) - kernel_size // 2
+    gauss = torch.exp(-x.pow(2) / (2 * sigma**2))
+    gauss = gauss / gauss.sum()
+
+    # Create 2D kernel
+    kernel = gauss.unsqueeze(0) * gauss.unsqueeze(1)
+    kernel = kernel.unsqueeze(0).unsqueeze(0)
+
+    # Apply blur per channel
+    batch_size, h, w, channels = tensor.shape
+    tensor_reshaped = tensor.permute(0, 3, 1, 2)  # [B, C, H, W]
+
+    # Expand kernel for all channels
+    kernel = kernel.repeat(channels, 1, 1, 1)
+
+    # Apply convolution with padding
+    padding = kernel_size // 2
+    blurred = F.conv2d(tensor_reshaped, kernel, padding=padding, groups=channels)
+
+    return blurred.permute(0, 2, 3, 1)  # Back to [B, H, W, C]
+
+
+def generate_grain_texture(
+    batch_size: int, height: int, width: int, scale: float, seed: int
+) -> torch.Tensor:
+    """
+    Generate base grain texture at specified scale.
+
+    Args:
+        batch_size: Number of images in batch
+        height: Target height
+        width: Target width
+        scale: Scale factor for grain size (larger = coarser grain)
+        seed: Random seed for reproducibility
+
+    Returns:
+        Grain texture tensor of shape [B, H/scale, W/scale, 3]
+    """
+    torch.manual_seed(seed)
+
+    grain_height = max(1, int(height / scale))
+    grain_width = max(1, int(width / scale))
+
+    # Generate random noise
+    grain = torch.rand(batch_size, grain_height, grain_width, 3)
+
+    return grain
+
+
+def apply_film_grain(
+    image: torch.Tensor,
+    scale: float = 0.5,
+    strength: float = 0.5,
+    saturation: float = 0.7,
+    toe: float = 0.0,
+    seed: int = 0,
+) -> torch.Tensor:
+    """
+    Apply film grain effect to an image with improved algorithms.
+
+    Improvements over original:
+    - Better color space conversion using ITU-R BT.709 coefficients
+    - More efficient Gaussian blur using PyTorch convolutions
+    - Improved grain mixing with better channel weighting
+    - Preserves alpha channel if present
+    - Better memory efficiency
+
+    Args:
+        image: Input tensor of shape [B, H, W, C] in range [0, 1]
+        scale: Grain size (0.25-2.0, higher = coarser grain)
+        strength: Grain intensity (0.0-10.0)
+        saturation: Color saturation of grain (0.0-2.0)
+        toe: Lift blacks/shadows (-0.2-0.5)
+        seed: Random seed for reproducibility
+
+    Returns:
+        Image with film grain applied
+    """
+    if strength == 0.0:
+        return image
+
+    # Handle empty batch
+    if image.shape[0] == 0:
+        return image
+
+    result = image.detach().clone()
+    has_alpha = image.shape[-1] == 4
+
+    # Generate grain texture
+    grain = generate_grain_texture(
+        image.shape[0], image.shape[1], image.shape[2], scale, seed
+    )
+
+    # Convert to YCbCr for better grain application
+    grain_ycbcr = rgb_to_ycbcr(grain)
+
+    # Apply different blur kernels to each channel for more realistic grain
+    # Y channel - fine detail
+    grain_ycbcr[:, :, :, 0] = apply_gaussian_blur(
+        grain_ycbcr[:, :, :, 0:1], kernel_size=3
+    ).squeeze(-1)
+
+    # Cb channel - medium blur for color noise
+    grain_ycbcr[:, :, :, 1] = apply_gaussian_blur(
+        grain_ycbcr[:, :, :, 1:2], kernel_size=15
+    ).squeeze(-1)
+
+    # Cr channel - slightly less blur
+    grain_ycbcr[:, :, :, 2] = apply_gaussian_blur(
+        grain_ycbcr[:, :, :, 2:3], kernel_size=11
+    ).squeeze(-1)
+
+    # Convert back to RGB
+    grain = ycbcr_to_rgb(grain_ycbcr)
+
+    # Center grain around 0 and apply strength
+    grain = (grain - 0.5) * strength
+
+    # Apply channel-specific weighting for more realistic film grain
+    # Film grain is typically stronger in blue channel, moderate in red
+    grain[:, :, :, 0] *= 2.0  # Red channel
+    grain[:, :, :, 1] *= 1.0  # Green channel (reference)
+    grain[:, :, :, 2] *= 3.0  # Blue channel
+
+    # Add 1 to make it multiplicative
+    grain = grain + 1.0
+
+    # Apply saturation control
+    # Extract luminance for desaturation mixing
+    luminance = grain[:, :, :, 1:2]  # Use green channel as approximation
+    grain = grain * saturation + luminance * (1 - saturation)
+
+    # Interpolate grain to match image size if needed
+    if grain.shape[1] != image.shape[1] or grain.shape[2] != image.shape[2]:
+        grain = F.interpolate(
+            grain.permute(0, 3, 1, 2),
+            size=(image.shape[1], image.shape[2]),
+            mode="bilinear",
+            align_corners=False,
+        ).permute(0, 2, 3, 1)
+
+    # Apply grain using screen blend mode: 1 - (1 - image) * grain
+    # This preserves highlights better than multiply
+    if has_alpha:
+        # Only apply to RGB channels
+        result[:, :, :, :3] = 1 - (1 - result[:, :, :, :3]) * grain
+    else:
+        result = 1 - (1 - result[:, :, :, :3]) * grain
+
+    # Apply toe adjustment (lift blacks)
+    if has_alpha:
+        result[:, :, :, :3] = result[:, :, :, :3] * (1 - toe) + toe
+    else:
+        result = result * (1 - toe) + toe
+
+    # Ensure output is in valid range
+    return torch.clamp(result, 0, 1)

kikotools/tools/kiko_film_grain/node.py

@@ -0,0 +1,123 @@
+import torch
+from typing import Dict, Any, Tuple
+
+from ...base import ComfyAssetsBaseNode
+from .logic import apply_film_grain
+
+
+class KikoFilmGrainNode(ComfyAssetsBaseNode):
+    """
+    Apply realistic film grain effect to images.
+
+    This node simulates the grain patterns found in analog film photography.
+    It provides controls for grain size, intensity, color saturation, and
+    shadow lifting (toe) to achieve various film looks.
+
+    Improvements over reference implementation:
+    - More efficient PyTorch-based blur operations
+    - Better memory management for large batches
+    - Preserves alpha channel when present
+    - Improved grain mixing algorithm
+    - ITU-R BT.709 color space conversion
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls) -> Dict[str, Any]:
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "scale": (
+                    "FLOAT",
+                    {
+                        "default": 0.5,
+                        "min": 0.25,
+                        "max": 2.0,
+                        "step": 0.05,
+                        "display": "slider",
+                        "description": "Grain size - smaller values create finer grain",
+                    },
+                ),
+                "strength": (
+                    "FLOAT",
+                    {
+                        "default": 0.5,
+                        "min": 0.0,
+                        "max": 10.0,
+                        "step": 0.01,
+                        "display": "slider",
+                        "description": "Intensity of the grain effect",
+                    },
+                ),
+                "saturation": (
+                    "FLOAT",
+                    {
+                        "default": 0.7,
+                        "min": 0.0,
+                        "max": 2.0,
+                        "step": 0.01,
+                        "display": "slider",
+                        "description": "Color saturation of the grain (0=monochrome)",
+                    },
+                ),
+                "toe": (
+                    "FLOAT",
+                    {
+                        "default": 0.0,
+                        "min": -0.2,
+                        "max": 0.5,
+                        "step": 0.001,
+                        "display": "slider",
+                        "description": "Lift blacks/shadows for a film-like look",
+                    },
+                ),
+                "seed": (
+                    "INT",
+                    {
+                        "default": 0,
+                        "min": 0,
+                        "max": 0xFFFFFFFFFFFFFFFF,
+                        "description": "Random seed for grain pattern generation",
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = "apply_grain"
+    CATEGORY = "🫶 ComfyAssets/💾 Images"
+    DESCRIPTION = "Apply realistic film grain effect with customizable parameters"
+
+    def apply_grain(
+        self,
+        image: torch.Tensor,
+        scale: float,
+        strength: float,
+        saturation: float,
+        toe: float,
+        seed: int,
+    ) -> Tuple[torch.Tensor]:
+        """
+        Apply film grain effect to the input image.
+
+        Args:
+            image: Input image tensor [B, H, W, C]
+            scale: Grain size factor (0.25-2.0)
+            strength: Grain intensity (0.0-10.0)
+            saturation: Color saturation of grain (0.0-2.0)
+            toe: Shadow lifting amount (-0.2-0.5)
+            seed: Random seed for reproducibility
+
+        Returns:
+            Tuple containing the processed image tensor
+        """
+        result = apply_film_grain(
+            image=image,
+            scale=scale,
+            strength=strength,
+            saturation=saturation,
+            toe=toe,
+            seed=seed,
+        )
+
+        return (result,)

kikotools/tools/kiko_purge_vram/__init__.py

@@ -0,0 +1,3 @@
+from .node import KikoPurgeVRAM
+
+__all__ = ["KikoPurgeVRAM"]

kikotools/tools/kiko_purge_vram/logic.py

@@ -0,0 +1,130 @@
+import gc
+from typing import Dict, Tuple
+
+try:
+    import torch
+
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+
+try:
+    import comfy.model_management as mm
+
+    COMFY_AVAILABLE = True
+except ImportError:
+    COMFY_AVAILABLE = False
+
+
+def get_memory_stats() -> Dict[str, float]:
+    stats = {
+        "cuda_available": False,
+        "free_mb": 0,
+        "total_mb": 0,
+        "used_mb": 0,
+        "used_percent": 0,
+    }
+
+    if TORCH_AVAILABLE and torch.cuda.is_available():
+        stats["cuda_available"] = True
+        free, total = torch.cuda.mem_get_info()
+        free_mb = free / (1024 * 1024)
+        total_mb = total / (1024 * 1024)
+        used_mb = total_mb - free_mb
+
+        stats["free_mb"] = free_mb
+        stats["total_mb"] = total_mb
+        stats["used_mb"] = used_mb
+        stats["used_percent"] = (used_mb / total_mb) * 100 if total_mb > 0 else 0
+
+    return stats
+
+
+def purge_memory(mode: str = "soft", unload_models: bool = False) -> float:
+    before_stats = get_memory_stats()
+
+    if mode == "soft":
+        # Basic garbage collection and cache clearing
+        gc.collect()
+        if TORCH_AVAILABLE and torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    elif mode == "aggressive":
+        # Multiple passes of garbage collection with full cache clearing
+        gc.collect()
+        gc.collect()
+        if TORCH_AVAILABLE and torch.cuda.is_available():
+            torch.cuda.synchronize()
+            torch.cuda.empty_cache()
+            torch.cuda.ipc_collect()
+
+    elif mode == "models_only":
+        # Only unload models
+        if COMFY_AVAILABLE:
+            mm.unload_all_models()
+            mm.soft_empty_cache()
+        gc.collect()
+
+    elif mode == "cache_only":
+        # Only clear cache without garbage collection
+        if TORCH_AVAILABLE and torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    # Handle model unloading for non-model-specific modes
+    if unload_models and mode not in ["models_only"]:
+        if COMFY_AVAILABLE:
+            mm.unload_all_models()
+            mm.soft_empty_cache()
+
+    after_stats = get_memory_stats()
+    freed_mb = before_stats["used_mb"] - after_stats["used_mb"]
+
+    return max(0, freed_mb)
+
+
+def format_memory_report(
+    before: Dict[str, float], after: Dict[str, float], mode: str, elapsed_ms: float
+) -> str:
+    if not before.get("cuda_available", True):
+        return (
+            "Memory Purge Report\n"
+            "-------------------\n"
+            "CUDA not available - CPU memory management only\n"
+            f"Mode: {mode}\n"
+            f"Time: {elapsed_ms:.1f}ms"
+        )
+
+    freed_mb = before["used_mb"] - after["used_mb"]
+
+    report = [
+        "Memory Purge Report",
+        "-------------------",
+        f"Mode: {mode}",
+        f"Memory Freed: {freed_mb:.1f} MB",
+        f"Before: {before['used_mb']:.1f} MB used ({before['used_percent']:.1f}%)",
+        f"After: {after['used_mb']:.1f} MB used ({after['used_percent']:.1f}%)",
+        f"Time: {elapsed_ms:.1f}ms",
+    ]
+
+    return "\n".join(report)
+
+
+def should_purge(threshold_mb: int) -> Tuple[bool, str]:
+    if threshold_mb <= 0:
+        return True, ""
+
+    stats = get_memory_stats()
+
+    if not stats["cuda_available"]:
+        return True, "CUDA not available, proceeding with CPU memory management"
+
+    if stats["used_mb"] >= threshold_mb:
+        return (
+            True,
+            f"Memory usage ({stats['used_mb']:.1f} MB) exceeds threshold ({threshold_mb} MB)",
+        )
+    else:
+        return (
+            False,
+            f"Memory usage ({stats['used_mb']:.1f} MB) below threshold ({threshold_mb} MB)",
+        )

kikotools/tools/kiko_purge_vram/node.py

@@ -0,0 +1,102 @@
+import time
+from typing import Any, Dict, Tuple
+
+try:
+    from ...base.base_node import ComfyAssetsBaseNode as BaseNode
+    from ...base.any_type import AnyType
+except ImportError:
+    # Fallback for testing environment
+    from kikotools.base.base_node import ComfyAssetsBaseNode as BaseNode
+    from kikotools.base.any_type import AnyType
+from .logic import get_memory_stats, purge_memory, format_memory_report, should_purge
+
+any_type = AnyType("*")
+
+
+class KikoPurgeVRAM(BaseNode):
+    @classmethod
+    def INPUT_TYPES(cls) -> Dict[str, Any]:
+        return {
+            "required": {
+                "anything": (any_type, {}),
+                "mode": (
+                    ["soft", "aggressive", "models_only", "cache_only"],
+                    {
+                        "default": "soft",
+                        "tooltip": "Purge mode: soft (basic), aggressive (thorough), models_only (unload models), cache_only (clear cache)",
+                    },
+                ),
+                "report_memory": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "Generate detailed memory usage report",
+                    },
+                ),
+            },
+            "optional": {
+                "memory_threshold_mb": (
+                    "INT",
+                    {
+                        "default": 0,
+                        "min": 0,
+                        "max": 48000,
+                        "step": 100,
+                        "tooltip": "Only purge if memory usage exceeds this threshold (0 = always purge)",
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = (any_type, "STRING")
+    RETURN_NAMES = ("passthrough", "memory_report")
+    FUNCTION = "purge_vram"
+    CATEGORY = "🫶 ComfyAssets/🛠️ Utils"
+    OUTPUT_NODE = True
+    DESCRIPTION = "Purge VRAM to free up GPU memory during workflow execution. Passes through any input unchanged."
+
+    def purge_vram(
+        self,
+        anything: Any,
+        mode: str,
+        report_memory: bool,
+        memory_threshold_mb: int = 0,
+    ) -> Tuple[Any, str]:
+        # Check if we should purge based on threshold
+        should_run, threshold_msg = should_purge(memory_threshold_mb)
+
+        if not should_run:
+            if report_memory:
+                return anything, f"Memory purge skipped: {threshold_msg}"
+            else:
+                return anything, ""
+
+        # Get before stats
+        before_stats = get_memory_stats() if report_memory else None
+        start_time = time.time()
+
+        # Determine if we should unload models
+        unload_models = mode in ["models_only", "aggressive"]
+
+        # Perform memory purge
+        purge_memory(mode=mode, unload_models=unload_models)
+
+        # Calculate elapsed time
+        elapsed_ms = (time.time() - start_time) * 1000
+
+        # Generate report if requested
+        if report_memory:
+            after_stats = get_memory_stats()
+            report = format_memory_report(before_stats, after_stats, mode, elapsed_ms)
+            if threshold_msg and memory_threshold_mb > 0:
+                report = f"{threshold_msg}\n\n{report}"
+        else:
+            report = ""
+
+        # Pass through the input unchanged
+        return anything, report
+
+
+NODE_CLASS_MAPPINGS = {"KikoPurgeVRAM": KikoPurgeVRAM}
+
+NODE_DISPLAY_NAME_MAPPINGS = {"KikoPurgeVRAM": "Kiko Purge VRAM"}

kikotools/tools/kiko_save_image/node.py

@@ -95,7 +95,7 @@ class KikoSaveImageNode(ComfyAssetsBaseNode):
         }
 
     RETURN_TYPES = ()
-    CATEGORY = "ComfyAssets/💾 Images"
+    CATEGORY = "🫶 ComfyAssets/💾 Images"
     FUNCTION = "save_images"
     OUTPUT_NODE = True
 

kikotools/tools/resolution_calculator/node.py

@@ -60,7 +60,7 @@ class ResolutionCalculatorNode(ComfyAssetsBaseNode):
         }
 
     RETURN_TYPES = ("INT", "INT")
-    CATEGORY = "ComfyAssets/🖼️ Resolution"
+    CATEGORY = "🫶 ComfyAssets/🖼️ Resolution"
     RETURN_NAMES = ("width", "height")
     FUNCTION = "calculate_resolution"
 

kikotools/tools/sampler_combo/compact_node.py

@@ -53,7 +53,6 @@ class SamplerComboCompactNode(ComfyAssetsBaseNode):
                         "min": 1.0,
                         "max": 15.0,
                         "step": 0.5,
-                        "display": "slider",
                         "tooltip": "CFG",
                     },
                 ),
@@ -63,7 +62,7 @@ class SamplerComboCompactNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("SAMPLER", SCHEDULERS, "INT", "FLOAT")
     RETURN_NAMES = ("sampler", "scheduler", "steps", "cfg")
     FUNCTION = "get_combo"
-    CATEGORY = "ComfyAssets/🌀 Samplers"
+    CATEGORY = "🫶 ComfyAssets/🌀 Samplers"
 
     def get_combo(
         self, sampler: str, sched: str, steps: int, cfg: float

kikotools/tools/sampler_combo/node.py

@@ -58,7 +58,6 @@ class SamplerComboNode(ComfyAssetsBaseNode):
                         "min": 0.0,
                         "max": 20.0,
                         "step": 0.5,
-                        "display": "slider",
                         "tooltip": "CFG scale (0-20)",
                     },
                 ),
@@ -68,7 +67,7 @@ class SamplerComboNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("SAMPLER", SCHEDULERS, "INT", "FLOAT")
     RETURN_NAMES = ("sampler_name", "scheduler", "steps", "cfg")
     FUNCTION = "get_sampler_combo"
-    CATEGORY = "ComfyAssets/🌀 Samplers"
+    CATEGORY = "🫶 ComfyAssets/🌀 Samplers"
 
     def get_sampler_combo(
         self, sampler_name: str, scheduler: str, steps: int, cfg: float

kikotools/tools/seed_history/node.py

@@ -38,7 +38,7 @@ class SeedHistoryNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("INT",)
     RETURN_NAMES = ("seed",)
     FUNCTION = "output_seed"
-    CATEGORY = "ComfyAssets/🌱 Seeds"
+    CATEGORY = "🫶 ComfyAssets/🌱 Seeds"
 
     def output_seed(self, seed: int) -> Tuple[int]:
         """

kikotools/tools/width_height_selector/node.py

@@ -85,7 +85,7 @@ class WidthHeightSelectorNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("INT", "INT")
     RETURN_NAMES = ("width", "height")
     FUNCTION = "get_dimensions"
-    CATEGORY = "ComfyAssets/🖼️ Resolution"
+    CATEGORY = "🫶 ComfyAssets/🖼️ Resolution"
 
     def get_dimensions(self, preset: str, width: int, height: int) -> Tuple[int, int]:
         """

kikotools/tools/xyz_helpers/flux_sampler_params/node.py

@@ -125,7 +125,7 @@ class FluxSamplerParamsNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("LATENT", "SAMPLER_PARAMS")
     RETURN_NAMES = ("latent", "params")
     FUNCTION = "process_batch"
-    CATEGORY = "ComfyAssets/🧰 xyz-helpers"
+    CATEGORY = "🫶 ComfyAssets/🧰 xyz-helpers"
 
     def process_batch(
         self,
@@ -352,6 +352,12 @@ class FluxSamplerParamsNode(ComfyAssetsBaseNode):
                                 < len(lora_strength[lora_file_idx])
                                 else 0
                             )
+                            # Add batch info if available
+                            if "batch_info" in loras:
+                                param_record["lora_batch"] = (
+                                    f"Batch {loras['batch_info']['index'] + 1}/"
+                                    f"{loras['batch_info']['total']}"
+                                )
 
                         out_params.append(param_record)
 

kikotools/tools/xyz_helpers/lora_folder_batch/logic.py

@@ -2,8 +2,7 @@
 
 import os
 import re
-from typing import List, Dict, Any, Tuple, Optional
-from pathlib import Path
+from typing import List, Dict, Any
 import logging
 
 logger = logging.getLogger(__name__)
@@ -36,7 +35,7 @@ def get_lora_folders() -> List[str]:
         return [".", "flux", "sdxl", "sd15"]
 
 
-def scan_folder_for_loras(folder_path: str) -> List[str]:
+def scan_folder_for_loras(folder_path: str) -> List[str]:  # noqa: C901
     """
     Scan a folder for LoRA files (.safetensors).
 
@@ -52,70 +51,85 @@ def scan_folder_for_loras(folder_path: str) -> List[str]:
         # Get all LoRA paths from ComfyUI (includes extra_model_paths)
         lora_paths = folder_paths.folder_names_and_paths.get("loras", [[]])[0]
 
+        # Determine the full path and base lora path
+        full_path = None
+        base_lora_path = None
+
         # Check if this is an absolute path
         if os.path.isabs(folder_path):
             full_path = folder_path
 
-            # Try to find which lora base path this belongs to
-            rel_folder = None
+            # Check if this path is inside any of the known lora directories
             for lora_base in lora_paths:
-                try:
-                    potential_rel = os.path.relpath(full_path, lora_base)
-                    if not potential_rel.startswith(".."):
-                        # This path is inside this lora base
-                        rel_folder = potential_rel
-                        break
-                except ValueError:
-                    # Different drives on Windows
-                    continue
+                # Normalize paths for comparison
+                norm_full = os.path.normpath(full_path)
+                norm_base = os.path.normpath(lora_base)
 
-            if rel_folder is None:
-                # Path is outside all known lora directories
-                # Try to extract a relative path that might work
-                # Check if path contains common lora folder structures
-                path_parts = full_path.replace("\\", "/").split("/")
-                if "lora" in path_parts or "loras" in path_parts:
-                    # Find index after lora/loras
+                # Check if full_path starts with this lora_base
+                if norm_full.startswith(norm_base):
+                    base_lora_path = lora_base
+                    break
+
+                # Also check if the path is a subdirectory under lora/loras
+                if "lora" in norm_full.lower():
+                    # Find the lora or loras directory in the path
+                    path_parts = norm_full.replace("\\", "/").split("/")
                     for i, part in enumerate(path_parts):
-                        if part in ["lora", "loras"]:
-                            # Use everything after lora/loras as relative path
-                            rel_folder = "/".join(path_parts[i + 1 :])
-                            break
-
-                if rel_folder is None:
-                    # Last resort: use last two directories as relative path
-                    rel_folder = (
-                        "/".join(path_parts[-2:])
-                        if len(path_parts) >= 2
-                        else path_parts[-1]
-                    )
+                        if part.lower() in ["lora", "loras"]:
+                            # Check if this matches our lora_base
+                            potential_base = "/".join(path_parts[: i + 1])
+                            if os.path.normpath(potential_base) == norm_base:
+                                base_lora_path = lora_base
+                                break
+                    if base_lora_path:
+                        break
         else:
             # Relative path provided
-            full_path = (
-                os.path.join(lora_paths[0], folder_path) if lora_paths else folder_path
-            )
-            rel_folder = folder_path if folder_path != "." else ""
+            base_lora_path = lora_paths[0] if lora_paths else ""
+            full_path = os.path.join(base_lora_path, folder_path)
 
         if not os.path.exists(full_path):
             logger.warning(f"Folder does not exist: {full_path}")
             return []
 
-        # Scan for .safetensors files
+        # Scan for .safetensors files recursively
         lora_files = []
-        for file in os.listdir(full_path):
-            if file.endswith(".safetensors"):
-                # Store relative path from lora base
-                if rel_folder and rel_folder != ".":
-                    lora_files.append(os.path.join(rel_folder, file).replace("\\", "/"))
-                else:
-                    lora_files.append(file)
+        for root, _, files in os.walk(full_path):
+            for file in files:
+                if file.endswith(".safetensors"):
+                    # Get the full path to the file
+                    file_full_path = os.path.join(root, file)
+
+                    # Calculate the correct relative path for ComfyUI
+                    if base_lora_path:
+                        # Path is inside a known lora directory
+                        try:
+                            rel_path = os.path.relpath(file_full_path, base_lora_path)
+                            lora_files.append(rel_path.replace("\\", "/"))
+                        except ValueError:
+                            # Different drives on Windows, use path relative to scan folder
+                            rel_path = os.path.relpath(file_full_path, full_path)
+                            if rel_path == ".":
+                                lora_files.append(file)
+                            else:
+                                lora_files.append(rel_path.replace("\\", "/"))
+                    else:
+                        # Path is outside known lora directories
+                        # Return path relative to the scanned folder
+                        rel_path = os.path.relpath(file_full_path, full_path)
+                        if rel_path == ".":
+                            lora_files.append(file)
+                        else:
+                            lora_files.append(rel_path.replace("\\", "/"))
 
         # Sort naturally (handles epoch numbers properly)
         lora_files = natural_sort(lora_files)
 
-        logger.info(
-            f"Found {len(lora_files)} LoRA files in {folder_path}, returning paths relative to lora base"
-        )
+        logger.info(f"Found {len(lora_files)} LoRA files in {folder_path}")
+        if lora_files and logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"Base lora path: {base_lora_path}")
+            logger.debug(f"Full scan path: {full_path}")
+            logger.debug(f"First few LoRA paths returned: {lora_files[:3]}")
         return lora_files
 
     except Exception as e:
@@ -123,6 +137,34 @@ def scan_folder_for_loras(folder_path: str) -> List[str]:
         return []
 
 
+def sort_lora_files(lora_files: List[str], sort_order: str) -> List[str]:
+    """
+    Sort LoRA files based on the specified order.
+
+    Args:
+        lora_files: List of LoRA file paths
+        sort_order: Type of sorting ("natural", "alphabetical", "newest", "oldest")
+
+    Returns:
+        Sorted list of LoRA files
+    """
+    if sort_order == "natural":
+        return natural_sort(lora_files)
+    elif sort_order == "alphabetical":
+        return sorted(lora_files)
+    elif sort_order in ["newest", "oldest"]:
+        # For time-based sorting, we need the actual file stats
+        # Since we only have relative paths, we'll sort by name for now
+        # This could be enhanced if we have access to file stats
+        sorted_files = natural_sort(lora_files)
+        if sort_order == "oldest":
+            return sorted_files
+        else:  # newest
+            return sorted_files[::-1]
+    else:
+        return lora_files
+
+
 def natural_sort(items: List[str]) -> List[str]:
     """
     Sort strings naturally, handling numbers properly.
@@ -140,10 +182,17 @@ def natural_sort(items: List[str]) -> List[str]:
 
         # Split on digits and filter out empty strings
         parts = [atoi(c) for c in re.split(r"(\d+)", text) if c]
-        # Put files without numbers first
-        if not any(isinstance(p, int) for p in parts):
-            return [0] + parts
-        return parts
+
+        # Convert to tuple of (type_order, value) to ensure consistent comparison
+        # Integers get type_order 0, strings get type_order 1
+        typed_parts = []
+        for part in parts:
+            if isinstance(part, int):
+                typed_parts.append((0, part))
+            else:
+                typed_parts.append((1, part))
+
+        return typed_parts
 
     return sorted(items, key=natural_key)
 
@@ -183,7 +232,7 @@ def filter_loras_by_pattern(
     return filtered
 
 
-def parse_strength_string(strength_str: str) -> List[float]:
+def parse_strength_string(strength_str: str) -> List[float]:  # noqa: C901
     """
     Parse strength string into list of values.
 
@@ -278,6 +327,57 @@ def create_lora_params(
         return {"loras": lora_files, "strengths": strength_lists}
 
 
+def create_lora_params_batched(
+    lora_files: List[str],
+    strengths: List[float],
+    batch_mode: str = "sequential",
+    batch_size: int = 25,
+) -> List[Dict[str, Any]]:
+    """
+    Create multiple LORA_PARAMS structures for FluxSamplerParams, batched for stability.
+
+    Args:
+        lora_files: List of LoRA file paths
+        strengths: List of strength values to test
+        batch_mode: How to batch ("sequential" or "combinatorial")
+        batch_size: Maximum number of LoRAs per batch
+
+    Returns:
+        List of LORA_PARAMS dictionaries, each with batch info
+    """
+    if not lora_files:
+        logger.warning("No LoRA files provided")
+        return [{"loras": [], "strengths": [], "batch_info": {"index": 0, "total": 0}}]
+
+    # Split lora_files into batches
+    batches = []
+    total_batches = (len(lora_files) + batch_size - 1) // batch_size
+
+    for i in range(0, len(lora_files), batch_size):
+        batch_loras = lora_files[i : i + batch_size]
+        batch_index = i // batch_size
+
+        # Create params for this batch
+        params = create_lora_params(batch_loras, strengths, batch_mode)
+
+        # Add batch tracking info
+        params["batch_info"] = {
+            "index": batch_index,
+            "total": total_batches,
+            "start_idx": i,
+            "end_idx": min(i + batch_size, len(lora_files)),
+            "size": len(batch_loras),
+        }
+
+        batches.append(params)
+
+    logger.info(f"Created {total_batches} batches of LoRAs (batch size: {batch_size})")
+    for i, batch in enumerate(batches):
+        logger.info(f"  Batch {i}: {batch['batch_info']['size']} LoRAs")
+
+    return batches
+
+
 def get_lora_info(lora_file: str) -> Dict[str, Any]:
     """
     Extract information from LoRA filename.
@@ -313,15 +413,25 @@ def validate_folder_path(folder_path: str) -> bool:
     Validate that the folder path exists and is accessible.
 
     Args:
-        folder_path: Folder path to validate
+        folder_path: Folder path to validate (absolute or relative)
 
     Returns:
         True if valid
     """
     try:
+        # Handle absolute paths
+        if os.path.isabs(folder_path):
+            return os.path.exists(folder_path) and os.path.isdir(folder_path)
+
+        # Handle relative paths
         import folder_paths
 
-        lora_base_path = folder_paths.folder_names_and_paths["loras"][0][0]
+        lora_paths = folder_paths.folder_names_and_paths.get("loras", [[]])[0]
+
+        if not lora_paths:
+            return False
+
+        lora_base_path = lora_paths[0]
 
         if folder_path == ".":
             full_path = lora_base_path

kikotools/tools/xyz_helpers/lora_folder_batch/node.py

@@ -1,15 +1,14 @@
 """LoRA Folder Batch node for ComfyUI."""
 
-from typing import Tuple, Any, Dict, List
-import os
+from typing import Tuple, Any, Dict
 import logging
 from ....base.base_node import ComfyAssetsBaseNode
 from .logic import (
-    get_lora_folders,
     scan_folder_for_loras,
     filter_loras_by_pattern,
     parse_strength_string,
     create_lora_params,
+    create_lora_params_batched,
     get_lora_info,
     validate_folder_path,
 )
@@ -74,21 +73,67 @@ class LoRAFolderBatchNode(ComfyAssetsBaseNode):
                         "tooltip": "Regex pattern to exclude files (e.g., 'test|backup')",
                     },
                 ),
+                "max_loras": (
+                    "INT",
+                    {
+                        "default": 50,
+                        "min": 1,
+                        "max": 500,
+                        "tooltip": "Maximum number of LoRAs to process (to prevent UI disconnection)",
+                    },
+                ),
+                "auto_batch": (
+                    ["disabled", "enabled"],
+                    {
+                        "default": "disabled",
+                        "tooltip": "Auto-batch large sets into chunks of 25 LoRAs",
+                    },
+                ),
+                "batch_size": (
+                    "INT",
+                    {
+                        "default": 25,
+                        "min": 5,
+                        "max": 100,
+                        "tooltip": "Number of LoRAs per batch when auto-batching",
+                    },
+                ),
+                "batch_index": (
+                    "INT",
+                    {
+                        "default": 0,
+                        "min": 0,
+                        "max": 100,
+                        "tooltip": "Which batch to output (0-based index)",
+                    },
+                ),
+                "sort_order": (
+                    ["natural", "alphabetical", "newest", "oldest"],
+                    {
+                        "default": "natural",
+                        "tooltip": "How to sort the LoRA files",
+                    },
+                ),
             },
         }
 
     RETURN_TYPES = ("LORA_PARAMS", "STRING", "INT")
     RETURN_NAMES = ("lora_params", "lora_list", "lora_count")
     FUNCTION = "batch_loras"
-    CATEGORY = "ComfyAssets/🧰 xyz-helpers"
+    CATEGORY = "🫶 ComfyAssets/🧰 xyz-helpers"
 
-    def batch_loras(
+    def batch_loras(  # noqa: C901
         self,
         folder_path: str,
         strength: str,
         batch_mode: str,
         include_pattern: str = "",
         exclude_pattern: str = "",
+        max_loras: int = 50,
+        sort_order: str = "natural",
+        auto_batch: str = "disabled",
+        batch_size: int = 25,
+        batch_index: int = 0,
     ) -> Tuple[Dict[str, Any], str, int]:
         """
         Batch process LoRAs from a folder.
@@ -137,37 +182,98 @@ class LoRAFolderBatchNode(ComfyAssetsBaseNode):
                 self.log_info("No LoRAs left after filtering")
                 return ({"loras": [], "strengths": []}, "", 0)
 
+            # Apply sorting based on sort_order
+            if sort_order != "natural":
+                from .logic import sort_lora_files
+
+                lora_files = sort_lora_files(lora_files, sort_order)
+
+            # Only limit if NOT auto-batching
+            if auto_batch == "disabled" and len(lora_files) > max_loras:
+                self.log_info(
+                    f"⚠️ Limiting to {max_loras} LoRAs (found {len(lora_files)}). "
+                    f"Enable auto_batch or increase max_loras to process more."
+                )
+                lora_files = lora_files[:max_loras]
+
             # Parse strength values
             strengths = parse_strength_string(strength)
             self.log_info(f"Using strength values: {strengths}")
 
-            # Create LORA_PARAMS
-            lora_params = create_lora_params(lora_files, strengths, batch_mode)
+            # Create LORA_PARAMS with auto-batching if enabled
+            if auto_batch == "enabled" and len(lora_files) > batch_size:
+                all_batches = create_lora_params_batched(
+                    lora_files, strengths, batch_mode, batch_size
+                )
 
-            # Create info string
+                # Check if batch_index is valid
+                if batch_index >= len(all_batches):
+                    self.log_info(
+                        f"⚠️ Batch index {batch_index} out of range. "
+                        f"Only {len(all_batches)} batches available. Using batch 0."
+                    )
+                    batch_index = 0
+
+                lora_params = all_batches[batch_index]
+
+                # Update lora_files to only include current batch for list display
+                batch_start = lora_params["batch_info"]["start_idx"]
+                batch_end = lora_params["batch_info"]["end_idx"]
+                lora_files_for_display = lora_files[batch_start:batch_end]
+            else:
+                # Regular single batch mode
+                lora_params = create_lora_params(lora_files, strengths, batch_mode)
+                lora_files_for_display = lora_files
+
+            # Create info string for current batch only
             lora_list = []
-            for lora_file in lora_files:
+            for lora_file in lora_files_for_display:
                 info = get_lora_info(lora_file)
                 if info["epoch"] is not None:
                     lora_list.append(f"{info['name']} (epoch {info['epoch']})")
                 else:
                     lora_list.append(info["name"])
 
-            lora_list_str = "\n".join(lora_list)
-
-            # Calculate total combinations
-            if batch_mode == "combinatorial":
-                total_combos = len(lora_files) * len(strengths)
+            # Add batch info to the list string if auto-batching
+            if auto_batch == "enabled" and "batch_info" in lora_params:
+                batch_header = (
+                    f"=== Batch {batch_index + 1}/{lora_params['batch_info']['total']} "
+                    f"(LoRAs {lora_params['batch_info']['start_idx'] + 1}-"
+                    f"{lora_params['batch_info']['end_idx']}) ===\n\n"
+                )
+                lora_list_str = batch_header + "\n".join(lora_list)
             else:
-                total_combos = len(lora_files)
+                lora_list_str = "\n".join(lora_list)
 
-            self.log_info(
-                f"Created batch with {len(lora_files)} LoRAs, "
-                f"{len(strengths)} strength values, "
-                f"{total_combos} total combinations"
-            )
+            # Calculate total combinations for current batch
+            current_batch_loras = len(lora_files_for_display)
+            if batch_mode == "combinatorial":
+                total_combos = current_batch_loras * len(strengths)
+            else:
+                total_combos = current_batch_loras
 
-            return (lora_params, lora_list_str, len(lora_files))
+            # Warn if generating many combinations
+            if total_combos > 100:
+                self.log_info(
+                    f"⚠️ WARNING: Generating {total_combos} combinations! "
+                    f"This may cause UI disconnection. Consider reducing max_loras or strength values."
+                )
+
+            if auto_batch == "enabled" and "batch_info" in lora_params:
+                self.log_info(
+                    f"Output batch {batch_index + 1}/{lora_params['batch_info']['total']} "
+                    f"with {current_batch_loras} LoRAs, "
+                    f"{len(strengths)} strength values, "
+                    f"{total_combos} total combinations"
+                )
+            else:
+                self.log_info(
+                    f"Created batch with {current_batch_loras} LoRAs, "
+                    f"{len(strengths)} strength values, "
+                    f"{total_combos} total combinations"
+                )
+
+            return (lora_params, lora_list_str, current_batch_loras)
 
         except Exception as e:
             self.handle_error(f"Error creating LoRA batch: {str(e)}", e)

kikotools/tools/xyz_helpers/plot_sampler_params/logic.py

@@ -203,7 +203,11 @@ def format_parameter_text(param: Dict, mode: str = "full") -> str:
         # Optional LoRA line
         if "lora" in param and param["lora"]:
             lora_name = param["lora"][:32] if len(param["lora"]) > 32 else param["lora"]
-            lines.append(f"LoRA: {lora_name}, str: {param.get('lora_strength', 'N/A')}")
+            lora_line = f"LoRA: {lora_name}, str: {param.get('lora_strength', 'N/A')}"
+            # Add batch info if available
+            if "lora_batch" in param:
+                lora_line += f" [{param['lora_batch']}]"
+            lines.append(lora_line)
 
         return "\n".join(lines)
 

kikotools/tools/xyz_helpers/plot_sampler_params/node.py

@@ -113,7 +113,7 @@ class PlotParametersNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("IMAGE",)
     RETURN_NAMES = ("image",)
     FUNCTION = "plot_parameters"
-    CATEGORY = "ComfyAssets/🧰 xyz-helpers"
+    CATEGORY = "🫶 ComfyAssets/🧰 xyz-helpers"
 
     def plot_parameters(
         self,

kikotools/tools/xyz_helpers/sampler_select_helper/node.py

@@ -30,7 +30,7 @@ class SamplerSelectHelperNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("STRING",)
     RETURN_NAMES = ("selected_samplers",)
     FUNCTION = "select_samplers"
-    CATEGORY = "ComfyAssets/🧰 xyz-helpers"
+    CATEGORY = "🫶 ComfyAssets/🧰 xyz-helpers"
 
     def select_samplers(self, **sampler_flags) -> Tuple[str]:
         """

kikotools/tools/xyz_helpers/scheduler_select_helper/node.py

@@ -30,7 +30,7 @@ class SchedulerSelectHelperNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("STRING",)
     RETURN_NAMES = ("selected_schedulers",)
     FUNCTION = "select_schedulers"
-    CATEGORY = "ComfyAssets/🧰 xyz-helpers"
+    CATEGORY = "🫶 ComfyAssets/🧰 xyz-helpers"
 
     def select_schedulers(self, **scheduler_flags) -> Tuple[str]:
         """

kikotools/tools/xyz_helpers/text_encode_sampler_params/node.py

@@ -40,7 +40,7 @@ class TextEncodeSamplerParamsNode(ComfyAssetsBaseNode):
     RETURN_TYPES = ("CONDITIONING",)
     RETURN_NAMES = ("conditioning",)
     FUNCTION = "encode_prompts"
-    CATEGORY = "ComfyAssets/🧰 xyz-helpers"
+    CATEGORY = "🫶 ComfyAssets/🧰 xyz-helpers"
 
     def encode_prompts(self, text: str, clip: Any) -> Tuple[Any]:
         """

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "kikotools"
 description = "Simple tools for ComfyUI"
-version = "1.0.11"
+version = "1.0.18"
 license = {text = "MIT"}
 dependencies = []
 

tests/conftest.py

@@ -3,10 +3,17 @@ pytest configuration and fixtures for ComfyUI-KikoTools testing
 Provides mock ComfyUI environments and test data
 """
 
+import sys
 import pytest
 import torch
 from unittest.mock import MagicMock
 
+# Mock folder_paths module before any imports that might use it
+sys.modules["folder_paths"] = MagicMock()
+sys.modules["folder_paths"].get_filename_list = MagicMock(return_value=[])
+sys.modules["folder_paths"].get_folder_paths = MagicMock(return_value=["/mock/path"])
+sys.modules["folder_paths"].base_path = "/mock/base"
+
 
 @pytest.fixture
 def mock_image_tensor():

tests/test_embedding_autocomplete.py

@@ -0,0 +1,92 @@
+"""Basic tests for KikoEmbeddingAutocomplete."""
+
+import sys
+from unittest.mock import MagicMock, patch
+
+
+def test_import():
+    """Test that the module can be imported."""
+    from kikotools.tools.embedding_autocomplete import KikoEmbeddingAutocomplete
+
+    assert KikoEmbeddingAutocomplete is not None
+    assert (
+        KikoEmbeddingAutocomplete.DISPLAY_NAME == "🫶 Embedding Autocomplete Settings"
+    )
+    assert KikoEmbeddingAutocomplete.CATEGORY == "🫶 ComfyAssets"
+
+
+def test_settings_defined():
+    """Test that settings are properly defined."""
+    from kikotools.tools.embedding_autocomplete import KikoEmbeddingAutocomplete
+
+    settings = KikoEmbeddingAutocomplete.SETTINGS
+    assert "enabled" in settings
+    assert "min_chars" in settings  # Changed from trigger_chars
+    assert "max_suggestions" in settings
+    assert "show_embeddings" in settings
+    assert "show_loras" in settings
+    assert "embedding_trigger" in settings
+    assert "lora_trigger" in settings
+    assert "quick_trigger" in settings
+    assert "sort_by_directory" in settings
+
+    # Check settings structure
+    assert settings["enabled"]["type"] == "boolean"
+    assert settings["enabled"]["default"] is True
+    assert settings["min_chars"]["type"] == "combo"
+    assert settings["min_chars"]["options"] == [1, 2, 3, 4, 5]
+
+
+def test_input_types():
+    """Test INPUT_TYPES class method."""
+    from kikotools.tools.embedding_autocomplete import KikoEmbeddingAutocomplete
+
+    input_types = KikoEmbeddingAutocomplete.INPUT_TYPES()
+    assert "required" in input_types
+    assert "hidden" in input_types
+    assert input_types["required"] == {}  # No required inputs
+    assert "unique_id" in input_types["hidden"]
+
+
+def test_api_suggestions():
+    """Test the API suggestions method."""
+    from kikotools.tools.embedding_autocomplete.node import (
+        KikoEmbeddingAutocompleteAPI,
+        folder_paths,
+    )
+
+    # Mock folder_paths if it exists (will be None in tests)
+    with patch("kikotools.tools.embedding_autocomplete.node.folder_paths") as mock_fp:
+        mock_fp.get_filename_list = MagicMock(
+            side_effect=lambda x: (
+                ["test1.pt", "test2.safetensors"]
+                if x == "embeddings"
+                else ["lora1.pt", "lora2.safetensors"]
+            )
+        )
+
+        # Test with embeddings
+        suggestions = KikoEmbeddingAutocompleteAPI.get_suggestions(
+            prefix="test", include_embeddings=True, include_loras=False
+        )
+
+        assert len(suggestions) == 2
+        assert suggestions[0]["type"] == "embedding"
+        assert suggestions[0]["name"] == "test1"
+
+        # Test with LoRAs
+        suggestions = KikoEmbeddingAutocompleteAPI.get_suggestions(
+            prefix="lora", include_embeddings=False, include_loras=True
+        )
+
+        assert len(suggestions) == 2
+        assert suggestions[0]["type"] == "lora"
+        assert "<lora:" in suggestions[0]["value"]
+
+
+if __name__ == "__main__":
+    test_import()
+    test_settings_defined()
+    test_input_types()
+    test_api_suggestions()
+    print("All tests passed!")

tests/test_embedding_paths.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Test script to check how ComfyUI returns embedding paths."""
+
+import sys
+import os
+
+# Add ComfyUI to path if available
+comfyui_path = os.path.expanduser("~/ComfyUI")
+if os.path.exists(comfyui_path):
+    sys.path.insert(0, comfyui_path)
+
+try:
+    import folder_paths
+
+    print("Testing embedding paths...")
+    print("=" * 50)
+
+    # Get embeddings
+    embeddings = folder_paths.get_filename_list("embeddings")
+    print(f"Total embeddings found: {len(embeddings)}")
+    print("\nFirst 20 embeddings:")
+    for i, emb in enumerate(embeddings[:20]):
+        print(f"  {i+1}. '{emb}'")
+
+    print("\n" + "=" * 50)
+    print("Checking for path separators...")
+    has_paths = any("/" in emb or "\\" in emb for emb in embeddings)
+    print(f"Contains path separators: {has_paths}")
+
+    if has_paths:
+        print("\nEmbeddings with paths:")
+        for emb in embeddings[:10]:
+            if "/" in emb or "\\" in emb:
+                print(f"  - {emb}")
+
+except ImportError as e:
+    print(f"Could not import folder_paths: {e}")
+    print("\nThis script should be run from within ComfyUI environment")

tests/test_folder_paths.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Test what folder_paths.get_filename_list actually returns."""
+
+import sys
+import os
+
+# Add ComfyUI to path
+comfyui_path = "/home/vito/ai-apps/ComfyUI-3.12"
+if os.path.exists(comfyui_path):
+    sys.path.insert(0, comfyui_path)
+    # Set the working directory for folder_paths
+    os.environ["COMFYUI_PATH"] = comfyui_path
+
+    try:
+        import folder_paths
+
+        print("Testing folder_paths.get_filename_list('embeddings')...")
+        print("=" * 60)
+
+        embeddings = folder_paths.get_filename_list("embeddings")
+        print(f"Total embeddings: {len(embeddings)}")
+
+        print("\nFirst 10 embeddings:")
+        for i, emb in enumerate(embeddings[:10]):
+            print(f"  {i+1}. '{emb}'")
+
+        # Check if any have paths
+        with_paths = [e for e in embeddings if "/" in e or "\\" in e]
+        print(f"\nEmbeddings with path separators: {len(with_paths)}")
+        if with_paths:
+            print("Examples:")
+            for e in with_paths[:5]:
+                print(f"  - '{e}'")
+
+        # Check the actual folder structure
+        print("\n" + "=" * 60)
+        print("Checking actual folder structure...")
+        emb_folders = folder_paths.get_folder_paths("embeddings")
+        print(f"Embedding folders: {emb_folders}")
+
+        if emb_folders:
+            emb_dir = emb_folders[0]
+            print(f"\nContents of {emb_dir}:")
+            for root, dirs, files in os.walk(emb_dir):
+                rel_root = os.path.relpath(root, emb_dir)
+                if rel_root == ".":
+                    rel_root = ""
+                for f in files[:5]:  # Show first 5 files in each dir
+                    if f.endswith((".pt", ".safetensors", ".ckpt")):
+                        full_path = os.path.join(rel_root, f) if rel_root else f
+                        print(f"  - '{full_path}'")
+                if len(files) > 5:
+                    print(f"  ... and {len(files)-5} more files")
+                if dirs:
+                    print(f"  Subdirectories: {dirs}")
+
+    except ImportError as e:
+        print(f"Could not import folder_paths: {e}")
+else:
+    print(f"ComfyUI not found at {comfyui_path}")

tests/unit/test_base_node.py

@@ -14,7 +14,7 @@ class TestComfyAssetsBaseNode:
 
     def test_category_is_comfy_assets(self):
         """Test that CATEGORY is set to ComfyAssets"""
-        assert ComfyAssetsBaseNode.CATEGORY == "ComfyAssets"
+        assert ComfyAssetsBaseNode.CATEGORY == "🫶 ComfyAssets"
 
     def test_validate_inputs_default_implementation(self):
         """Test default validate_inputs does nothing"""
@@ -69,7 +69,7 @@ class TestComfyAssetsBaseNode:
 
         assert isinstance(info, dict)
         assert info["class_name"] == "ComfyAssetsBaseNode"
-        assert info["category"] == "ComfyAssets"
+        assert info["category"] == "🫶 ComfyAssets"
         assert info["function"] == "Unknown"  # Base class doesn't have FUNCTION
         assert info["return_types"] == ()
         assert info["return_names"] == ()
@@ -91,14 +91,14 @@ class TestConcreteNodeInheritance:
 
     def test_concrete_node_inherits_category(self):
         """Test concrete node inherits ComfyAssets category"""
-        assert MockConcreteNode.CATEGORY == "ComfyAssets"
+        assert MockConcreteNode.CATEGORY == "🫶 ComfyAssets"
 
     def test_concrete_node_get_info_includes_specific_attributes(self):
         """Test concrete node info includes its specific attributes"""
         info = MockConcreteNode.get_node_info()
 
         assert info["class_name"] == "MockConcreteNode"
-        assert info["category"] == "ComfyAssets"
+        assert info["category"] == "🫶 ComfyAssets"
         assert info["function"] == "mock_function"
         assert info["return_types"] == ("STRING", "INT")
         assert info["return_names"] == ("text", "number")

tests/unit/tools/test_display_any.py

@@ -40,7 +40,7 @@ class TestDisplayAnyNode:
 
     def test_node_properties(self):
         """Test node has correct properties."""
-        assert DisplayAnyNode.CATEGORY == "ComfyAssets/👁️ Display"
+        assert DisplayAnyNode.CATEGORY == "🫶 ComfyAssets/👁️ Display"
         assert DisplayAnyNode.FUNCTION == "display"
         assert DisplayAnyNode.RETURN_TYPES == ("STRING",)
         assert DisplayAnyNode.RETURN_NAMES == ("display_text",)

tests/unit/tools/test_empty_latent_batch.py

@@ -134,7 +134,7 @@ class TestEmptyLatentBatchNode:
         assert EmptyLatentBatchNode.RETURN_TYPES == ("LATENT", "INT", "INT")
         assert EmptyLatentBatchNode.RETURN_NAMES == ("latent", "width", "height")
         assert EmptyLatentBatchNode.FUNCTION == "create_empty_latent"
-        assert EmptyLatentBatchNode.CATEGORY == "ComfyAssets/📦 Latents"
+        assert EmptyLatentBatchNode.CATEGORY == "🫶 ComfyAssets/📦 Latents"
 
     def test_create_empty_latent_basic(self):
         """Test basic empty latent creation through node."""

tests/unit/tools/test_gemini_prompt.py

@@ -26,7 +26,7 @@ class TestGeminiPromptNode:
 
     def test_node_properties(self):
         """Test node has correct properties."""
-        assert GeminiPromptNode.CATEGORY == "ComfyAssets/🧠 Prompts"
+        assert GeminiPromptNode.CATEGORY == "🫶 ComfyAssets/🧠 Prompts"
         assert GeminiPromptNode.FUNCTION == "generate_prompt"
         assert GeminiPromptNode.RETURN_TYPES == ("STRING", "STRING")
         assert GeminiPromptNode.RETURN_NAMES == ("prompt", "negative_prompt")

tests/unit/tools/test_image_scale_down_by.py

@@ -145,7 +145,7 @@ class TestImageScaleDownByNode:
 
     def test_category_is_comfyassets(self):
         """Test that the node is in the ComfyAssets category."""
-        assert ImageScaleDownByNode.CATEGORY == "ComfyAssets/🖼️ Resolution"
+        assert ImageScaleDownByNode.CATEGORY == "🫶 ComfyAssets/🖼️ Resolution"
 
     def test_scale_down_with_batch(self, node):
         """Test scaling down with batch of images."""

tests/unit/tools/test_image_to_multiple_of.py

@@ -118,7 +118,7 @@ class TestImageToMultipleOfNode:
         assert ImageToMultipleOfNode.RETURN_TYPES == ("IMAGE",)
         assert ImageToMultipleOfNode.RETURN_NAMES == ("image",)
         assert ImageToMultipleOfNode.FUNCTION == "process"
-        assert ImageToMultipleOfNode.CATEGORY == "ComfyAssets/🖼️ Resolution"
+        assert ImageToMultipleOfNode.CATEGORY == "🫶 ComfyAssets/🖼️ Resolution"
 
     def test_node_process_center_crop(self):
         """Test node processing with center crop."""

tests/unit/tools/test_kiko_film_grain.py

@@ -0,0 +1,249 @@
+import pytest
+import torch
+import numpy as np
+from unittest.mock import MagicMock
+
+from kikotools.tools.kiko_film_grain.logic import (
+    apply_film_grain,
+    generate_grain_texture,
+    rgb_to_ycbcr,
+    ycbcr_to_rgb,
+    apply_gaussian_blur,
+)
+
+
+class TestColorSpaceConversion:
+    def test_rgb_to_ycbcr_conversion(self):
+        rgb = torch.tensor([[[[1.0, 0.0, 0.0]]]])  # Pure red
+        ycbcr = rgb_to_ycbcr(rgb)
+
+        assert ycbcr.shape == rgb.shape
+        assert 0.0 <= ycbcr[0, 0, 0, 0] <= 1.0  # Y channel
+
+    def test_ycbcr_to_rgb_conversion(self):
+        ycbcr = torch.tensor([[[[0.5, 0.0, 0.0]]]])
+        rgb = ycbcr_to_rgb(ycbcr)
+
+        assert rgb.shape == ycbcr.shape
+        assert rgb.min() >= 0.0
+        assert rgb.max() <= 1.0
+
+    def test_rgb_ycbcr_round_trip(self):
+        original = torch.rand(1, 4, 4, 3)
+        converted = ycbcr_to_rgb(rgb_to_ycbcr(original))
+
+        # Should be approximately equal after round trip
+        assert torch.allclose(original, converted, atol=0.01)
+
+
+class TestGaussianBlur:
+    def test_apply_gaussian_blur_no_blur(self):
+        image = torch.rand(1, 10, 10, 3)
+        blurred = apply_gaussian_blur(image, kernel_size=1)
+
+        # Kernel size 1 should not blur
+        assert torch.allclose(image, blurred, atol=0.001)
+
+    def test_apply_gaussian_blur_with_blur(self):
+        # Create sharp edge image
+        image = torch.zeros(1, 10, 10, 1)
+        image[:, :5, :, :] = 1.0
+
+        blurred = apply_gaussian_blur(image, kernel_size=3)
+
+        # Edge should be smoothed
+        edge_original = image[0, 4:6, 5, 0]
+        edge_blurred = blurred[0, 4:6, 5, 0]
+        # White side near edge should be darker due to blur
+        assert edge_blurred[0] < edge_original[0]
+        # Black side near edge should be lighter due to blur
+        assert edge_blurred[1] > edge_original[1]
+
+    def test_apply_gaussian_blur_preserves_shape(self):
+        for shape in [(1, 32, 32, 3), (2, 64, 128, 1), (4, 16, 16, 3)]:
+            image = torch.rand(*shape)
+            blurred = apply_gaussian_blur(image, kernel_size=5)
+            assert blurred.shape == image.shape
+
+
+class TestGrainGeneration:
+    def test_generate_grain_texture_shape(self):
+        batch_size = 2
+        height = 64
+        width = 128
+        scale = 2.0
+
+        grain = generate_grain_texture(batch_size, height, width, scale, seed=42)
+
+        expected_height = int(height / scale)
+        expected_width = int(width / scale)
+        assert grain.shape == (batch_size, expected_height, expected_width, 3)
+
+    def test_generate_grain_texture_deterministic(self):
+        grain1 = generate_grain_texture(1, 32, 32, 1.0, seed=123)
+        grain2 = generate_grain_texture(1, 32, 32, 1.0, seed=123)
+
+        assert torch.allclose(grain1, grain2)
+
+    def test_generate_grain_texture_different_seeds(self):
+        grain1 = generate_grain_texture(1, 32, 32, 1.0, seed=123)
+        grain2 = generate_grain_texture(1, 32, 32, 1.0, seed=456)
+
+        assert not torch.allclose(grain1, grain2)
+
+    def test_generate_grain_texture_scale_factor(self):
+        height, width = 64, 64
+        grain_1x = generate_grain_texture(1, height, width, 1.0, seed=42)
+        grain_2x = generate_grain_texture(1, height, width, 2.0, seed=42)
+
+        assert grain_1x.shape[1] == height
+        assert grain_2x.shape[1] == height // 2
+
+
+class TestFilmGrainApplication:
+    def test_apply_film_grain_no_effect(self):
+        image = torch.rand(1, 32, 32, 3)
+
+        # Zero strength should have no effect
+        result = apply_film_grain(
+            image, scale=1.0, strength=0.0, saturation=1.0, toe=0.0, seed=42
+        )
+
+        assert torch.allclose(image, result, atol=0.001)
+
+    def test_apply_film_grain_with_strength(self):
+        image = torch.ones(1, 32, 32, 3) * 0.5
+
+        result = apply_film_grain(
+            image, scale=1.0, strength=1.0, saturation=1.0, toe=0.0, seed=42
+        )
+
+        # Should add variation
+        assert not torch.allclose(image, result)
+        # Should remain in valid range
+        assert result.min() >= 0.0
+        assert result.max() <= 1.0
+
+    def test_apply_film_grain_saturation_effect(self):
+        image = torch.ones(1, 32, 32, 3) * 0.5
+
+        # Full saturation
+        result_saturated = apply_film_grain(
+            image, scale=1.0, strength=1.0, saturation=1.0, toe=0.0, seed=42
+        )
+
+        # No saturation (monochrome grain)
+        result_desaturated = apply_film_grain(
+            image, scale=1.0, strength=1.0, saturation=0.0, toe=0.0, seed=42
+        )
+
+        # Calculate color variance
+        var_saturated = torch.var(result_saturated, dim=-1).mean()
+        var_desaturated = torch.var(result_desaturated, dim=-1).mean()
+
+        # Desaturated should have less color variance
+        assert var_desaturated < var_saturated
+
+    def test_apply_film_grain_toe_effect(self):
+        image = torch.ones(1, 32, 32, 3) * 0.5
+
+        # No toe
+        result_no_toe = apply_film_grain(
+            image, scale=1.0, strength=0.5, saturation=1.0, toe=0.0, seed=42
+        )
+
+        # With toe (lifts blacks)
+        result_with_toe = apply_film_grain(
+            image, scale=1.0, strength=0.5, saturation=1.0, toe=0.2, seed=42
+        )
+
+        # Toe should generally lift the overall brightness
+        assert result_with_toe.mean() > result_no_toe.mean()
+
+    def test_apply_film_grain_batch_processing(self):
+        batch_size = 4
+        image = torch.rand(batch_size, 32, 32, 3)
+
+        result = apply_film_grain(
+            image, scale=1.5, strength=0.5, saturation=0.8, toe=0.1, seed=42
+        )
+
+        assert result.shape == image.shape
+
+        # Each image in batch should be different (due to grain)
+        for i in range(batch_size - 1):
+            assert not torch.allclose(result[i], result[i + 1])
+
+    def test_apply_film_grain_preserves_alpha(self):
+        # Image with alpha channel
+        image = torch.rand(1, 32, 32, 4)
+        original_alpha = image[:, :, :, 3:4].clone()
+
+        result = apply_film_grain(
+            image, scale=1.0, strength=1.0, saturation=1.0, toe=0.0, seed=42
+        )
+
+        # Alpha channel should be unchanged
+        assert torch.allclose(original_alpha, result[:, :, :, 3:4])
+
+    def test_apply_film_grain_scale_interpolation(self):
+        image = torch.ones(1, 64, 64, 3) * 0.5
+
+        # Different scales should produce different sized grain
+        result_fine = apply_film_grain(
+            image, scale=0.5, strength=0.5, saturation=1.0, toe=0.0, seed=42
+        )
+
+        result_coarse = apply_film_grain(
+            image, scale=2.0, strength=0.5, saturation=1.0, toe=0.0, seed=42
+        )
+
+        # Compute local variance to measure grain size
+        def compute_local_variance(img, window=3):
+            unfold = torch.nn.Unfold(kernel_size=window, stride=1, padding=1)
+            img_reshaped = img.permute(0, 3, 1, 2)
+            patches = unfold(img_reshaped)
+            var = torch.var(patches, dim=1)
+            return var.mean()
+
+        var_fine = compute_local_variance(result_fine)
+        var_coarse = compute_local_variance(result_coarse)
+
+        # Fine grain should have higher local variance than coarse grain
+        # (more rapid changes)
+        assert var_fine != var_coarse  # They should be different
+
+
+class TestEdgeCases:
+    def test_handles_empty_batch(self):
+        image = torch.rand(0, 32, 32, 3)
+        result = apply_film_grain(
+            image, scale=1.0, strength=0.5, saturation=1.0, toe=0.0, seed=42
+        )
+        assert result.shape == image.shape
+
+    def test_handles_single_pixel(self):
+        image = torch.rand(1, 1, 1, 3)
+        result = apply_film_grain(
+            image, scale=1.0, strength=0.5, saturation=1.0, toe=0.0, seed=42
+        )
+        assert result.shape == image.shape
+        assert result.min() >= 0.0
+        assert result.max() <= 1.0
+
+    def test_handles_extreme_parameters(self):
+        image = torch.rand(1, 32, 32, 3)
+
+        # Maximum strength
+        result = apply_film_grain(
+            image, scale=2.0, strength=10.0, saturation=2.0, toe=0.5, seed=42
+        )
+        assert result.min() >= 0.0
+        assert result.max() <= 1.0
+
+        # Minimum values
+        result = apply_film_grain(
+            image, scale=0.25, strength=0.0, saturation=0.0, toe=-0.2, seed=42
+        )
+        assert result.min() >= 0.0
+        assert result.max() <= 1.0

tests/unit/tools/test_kiko_purge_vram.py

@@ -0,0 +1,301 @@
+import sys
+from unittest.mock import patch, MagicMock
+
+import pytest
+
+# Mock comfy modules
+mock_mm = MagicMock()
+sys.modules["comfy"] = MagicMock()
+sys.modules["comfy.model_management"] = mock_mm
+
+from kikotools.tools.kiko_purge_vram.logic import (
+    purge_memory,
+    get_memory_stats,
+    format_memory_report,
+)
+
+# Ensure mm is available in the logic module after import
+import kikotools.tools.kiko_purge_vram.logic as logic_module
+
+logic_module.mm = mock_mm
+
+
+class TestMemoryStats:
+    @patch("torch.cuda.is_available")
+    @patch("torch.cuda.mem_get_info")
+    def test_get_memory_stats_with_cuda(self, mock_mem_info, mock_cuda_available):
+        mock_cuda_available.return_value = True
+        mock_mem_info.return_value = (4000000000, 8000000000)  # 4GB free, 8GB total
+
+        stats = get_memory_stats()
+
+        assert stats["cuda_available"] is True
+        assert stats["free_mb"] == pytest.approx(3814.7, rel=0.1)
+        assert stats["total_mb"] == pytest.approx(7629.4, rel=0.1)
+        assert stats["used_mb"] == pytest.approx(3814.7, rel=0.1)
+        assert stats["used_percent"] == pytest.approx(50.0, rel=0.1)
+
+    @patch("torch.cuda.is_available")
+    def test_get_memory_stats_without_cuda(self, mock_cuda_available):
+        mock_cuda_available.return_value = False
+
+        stats = get_memory_stats()
+
+        assert stats["cuda_available"] is False
+        assert stats["free_mb"] == 0
+        assert stats["total_mb"] == 0
+        assert stats["used_mb"] == 0
+        assert stats["used_percent"] == 0
+
+
+class TestMemoryPurge:
+    @patch("torch.cuda.is_available")
+    @patch("torch.cuda.empty_cache")
+    @patch("torch.cuda.ipc_collect")
+    @patch("gc.collect")
+    def test_purge_memory_soft_mode(
+        self, mock_gc, mock_ipc, mock_empty_cache, mock_cuda
+    ):
+        mock_cuda.return_value = True
+
+        with patch(
+            "kikotools.tools.kiko_purge_vram.logic.get_memory_stats"
+        ) as mock_stats:
+            mock_stats.side_effect = [
+                {"used_mb": 4000, "free_mb": 4000},
+                {"used_mb": 2000, "free_mb": 6000},
+            ]
+
+            freed_mb = purge_memory(mode="soft", unload_models=False)
+
+            mock_gc.assert_called_once()
+            mock_empty_cache.assert_called_once()
+            mock_ipc.assert_not_called()
+            assert freed_mb == 2000
+
+    @patch("torch.cuda.is_available")
+    @patch("torch.cuda.empty_cache")
+    @patch("torch.cuda.ipc_collect")
+    @patch("torch.cuda.synchronize")
+    @patch("gc.collect")
+    def test_purge_memory_aggressive_mode(
+        self, mock_gc, mock_sync, mock_ipc, mock_empty_cache, mock_cuda
+    ):
+        mock_cuda.return_value = True
+
+        with patch(
+            "kikotools.tools.kiko_purge_vram.logic.get_memory_stats"
+        ) as mock_stats:
+            mock_stats.side_effect = [
+                {"used_mb": 4000, "free_mb": 4000},
+                {"used_mb": 1500, "free_mb": 6500},
+            ]
+
+            freed_mb = purge_memory(mode="aggressive", unload_models=False)
+
+            assert mock_gc.call_count == 2
+            mock_empty_cache.assert_called()
+            mock_ipc.assert_called_once()
+            mock_sync.assert_called_once()
+            assert freed_mb == 2500
+
+    @patch("kikotools.tools.kiko_purge_vram.logic.COMFY_AVAILABLE", True)
+    @patch("torch.cuda.is_available")
+    @patch("gc.collect")
+    def test_purge_memory_models_only(self, mock_gc, mock_cuda):
+        mock_cuda.return_value = True
+
+        with patch(
+            "kikotools.tools.kiko_purge_vram.logic.get_memory_stats"
+        ) as mock_stats:
+            mock_stats.side_effect = [
+                {"used_mb": 6000, "free_mb": 2000},
+                {"used_mb": 1000, "free_mb": 7000},
+            ]
+
+            freed_mb = purge_memory(mode="models_only", unload_models=True)
+
+            mock_mm.unload_all_models.assert_called_once()
+            mock_mm.soft_empty_cache.assert_called_once()
+            mock_gc.assert_called()
+            assert freed_mb == 5000
+
+    @patch("torch.cuda.is_available")
+    @patch("torch.cuda.empty_cache")
+    @patch("gc.collect")
+    def test_purge_memory_cache_only(self, mock_gc, mock_empty_cache, mock_cuda):
+        mock_cuda.return_value = True
+
+        with patch(
+            "kikotools.tools.kiko_purge_vram.logic.get_memory_stats"
+        ) as mock_stats:
+            mock_stats.side_effect = [
+                {"used_mb": 3000, "free_mb": 5000},
+                {"used_mb": 2500, "free_mb": 5500},
+            ]
+
+            freed_mb = purge_memory(mode="cache_only", unload_models=False)
+
+            mock_gc.assert_not_called()
+            mock_empty_cache.assert_called_once()
+            assert freed_mb == 500
+
+    @patch("torch.cuda.is_available")
+    def test_purge_memory_no_cuda(self, mock_cuda):
+        mock_cuda.return_value = False
+
+        with patch("gc.collect") as mock_gc:
+            freed_mb = purge_memory(mode="soft", unload_models=False)
+
+            mock_gc.assert_called_once()
+            assert freed_mb == 0
+
+
+class TestMemoryReport:
+    def test_format_memory_report_with_improvement(self):
+        before = {
+            "used_mb": 4000,
+            "free_mb": 4000,
+            "total_mb": 8000,
+            "used_percent": 50,
+        }
+        after = {"used_mb": 2000, "free_mb": 6000, "total_mb": 8000, "used_percent": 25}
+
+        report = format_memory_report(before, after, mode="soft", elapsed_ms=150)
+
+        assert "Memory Purge Report" in report
+        assert "Mode: soft" in report
+        assert "Memory Freed: 2000.0 MB" in report
+        assert "Before: 4000.0 MB used (50.0%)" in report
+        assert "After: 2000.0 MB used (25.0%)" in report
+        assert "Time: 150.0ms" in report
+
+    def test_format_memory_report_no_improvement(self):
+        before = {
+            "used_mb": 2000,
+            "free_mb": 6000,
+            "total_mb": 8000,
+            "used_percent": 25,
+        }
+        after = {"used_mb": 2000, "free_mb": 6000, "total_mb": 8000, "used_percent": 25}
+
+        report = format_memory_report(before, after, mode="cache_only", elapsed_ms=50)
+
+        assert "Memory Freed: 0.0 MB" in report
+        assert "Time: 50.0ms" in report
+
+    def test_format_memory_report_no_cuda(self):
+        before = {
+            "used_mb": 0,
+            "free_mb": 0,
+            "total_mb": 0,
+            "used_percent": 0,
+            "cuda_available": False,
+        }
+        after = {
+            "used_mb": 0,
+            "free_mb": 0,
+            "total_mb": 0,
+            "used_percent": 0,
+            "cuda_available": False,
+        }
+
+        report = format_memory_report(before, after, mode="soft", elapsed_ms=10)
+
+        assert "CUDA not available" in report
+
+
+class TestKikoPurgeVRAMNode:
+    @patch("kikotools.tools.kiko_purge_vram.node.format_memory_report")
+    @patch("kikotools.tools.kiko_purge_vram.node.purge_memory")
+    @patch("kikotools.tools.kiko_purge_vram.node.get_memory_stats")
+    @patch("kikotools.tools.kiko_purge_vram.node.should_purge")
+    def test_node_execute_with_threshold(
+        self, mock_should_purge, mock_stats, mock_purge, mock_format
+    ):
+        from kikotools.tools.kiko_purge_vram.node import KikoPurgeVRAM
+
+        mock_should_purge.return_value = (
+            True,
+            "Memory usage (5000.0 MB) exceeds threshold (4000 MB)",
+        )
+        mock_stats.side_effect = [
+            {
+                "used_mb": 5000,
+                "free_mb": 3000,
+                "total_mb": 8000,
+                "used_percent": 62.5,
+                "cuda_available": True,
+            },
+            {
+                "used_mb": 2000,
+                "free_mb": 6000,
+                "total_mb": 8000,
+                "used_percent": 25,
+                "cuda_available": True,
+            },
+        ]
+        mock_purge.return_value = 3000
+        mock_format.return_value = "Memory Purge Report\n-------------------\nMode: soft\nMemory Freed: 3000.0 MB"
+
+        node = KikoPurgeVRAM()
+        test_input = "test_data"
+
+        result, report = node.purge_vram(
+            anything=test_input,
+            mode="soft",
+            report_memory=True,
+            memory_threshold_mb=4000,
+        )
+
+        assert result == test_input
+        assert "Memory Freed: 3000.0 MB" in report
+        mock_purge.assert_called_once_with(mode="soft", unload_models=False)
+
+    @patch("kikotools.tools.kiko_purge_vram.logic.get_memory_stats")
+    def test_node_skip_below_threshold(self, mock_stats):
+        from kikotools.tools.kiko_purge_vram.node import KikoPurgeVRAM
+
+        mock_stats.return_value = {
+            "used_mb": 2000,
+            "free_mb": 6000,
+            "total_mb": 8000,
+            "used_percent": 25,
+            "cuda_available": True,
+        }
+
+        node = KikoPurgeVRAM()
+        test_input = "test_data"
+
+        with patch("kikotools.tools.kiko_purge_vram.logic.purge_memory") as mock_purge:
+            result, report = node.purge_vram(
+                anything=test_input,
+                mode="soft",
+                report_memory=True,
+                memory_threshold_mb=3000,
+            )
+
+            assert result == test_input
+            assert "below threshold" in report.lower()
+            mock_purge.assert_not_called()
+
+    def test_node_input_types(self):
+        from kikotools.tools.kiko_purge_vram.node import KikoPurgeVRAM
+
+        input_types = KikoPurgeVRAM.INPUT_TYPES()
+
+        assert "required" in input_types
+        assert "optional" in input_types
+        assert "anything" in input_types["required"]
+        assert "mode" in input_types["required"]
+        assert "report_memory" in input_types["required"]
+        assert "memory_threshold_mb" in input_types["optional"]
+
+    def test_node_properties(self):
+        from kikotools.tools.kiko_purge_vram.node import KikoPurgeVRAM
+
+        assert KikoPurgeVRAM.FUNCTION == "purge_vram"
+        assert KikoPurgeVRAM.CATEGORY == "🫶 ComfyAssets/🛠️ Utils"
+        assert KikoPurgeVRAM.OUTPUT_NODE is True
+        assert len(KikoPurgeVRAM.RETURN_TYPES) == 2
+        assert KikoPurgeVRAM.RETURN_NAMES == ("passthrough", "memory_report")

tests/unit/tools/test_kiko_save_image.py

@@ -329,7 +329,7 @@ class TestKikoSaveImageNode:
         assert KikoSaveImageNode.RETURN_TYPES == ()
         assert KikoSaveImageNode.FUNCTION == "save_images"
         assert KikoSaveImageNode.OUTPUT_NODE is True
-        assert KikoSaveImageNode.CATEGORY == "ComfyAssets/💾 Images"
+        assert KikoSaveImageNode.CATEGORY == "🫶 ComfyAssets/💾 Images"
 
     @patch("kikotools.tools.kiko_save_image.node.process_image_batch")
     def test_save_images_success(self, mock_process):
@@ -436,7 +436,7 @@ class TestKikoSaveImageNode:
         info = self.node.get_node_info()
 
         assert info["class_name"] == "KikoSaveImageNode"
-        assert info["category"] == "ComfyAssets/💾 Images"
+        assert info["category"] == "🫶 ComfyAssets/💾 Images"
         assert info["function"] == "save_images"
 
 

tests/unit/tools/test_resolution_calculator.py

@@ -179,7 +179,7 @@ class TestResolutionCalculatorNode:
         assert hasattr(ResolutionCalculatorNode, "CATEGORY")
 
         # Check category is correct
-        assert ResolutionCalculatorNode.CATEGORY == "ComfyAssets/🖼️ Resolution"
+        assert ResolutionCalculatorNode.CATEGORY == "🫶 ComfyAssets/🖼️ Resolution"
 
         # Check return types
         assert ResolutionCalculatorNode.RETURN_TYPES == ("INT", "INT")
@@ -281,7 +281,7 @@ class TestResolutionCalculatorNode:
         node = ResolutionCalculatorNode()
         node_info = node.get_node_info()
 
-        assert node_info["category"] == "ComfyAssets/🖼️ Resolution"
+        assert node_info["category"] == "🫶 ComfyAssets/🖼️ Resolution"
         assert node_info["class_name"] == "ResolutionCalculatorNode"
 
 

tests/unit/tools/test_sampler_combo.py

@@ -186,7 +186,7 @@ class TestSamplerComboNode:
             "cfg",
         )
         assert SamplerComboNode.FUNCTION == "get_sampler_combo"
-        assert SamplerComboNode.CATEGORY == "ComfyAssets/🌀 Samplers"
+        assert SamplerComboNode.CATEGORY == "🫶 ComfyAssets/🌀 Samplers"
 
     def test_get_sampler_combo_valid_inputs(self):
         """Test get_sampler_combo with valid inputs."""

tests/unit/tools/test_seed_history.py

@@ -49,7 +49,7 @@ class TestSeedHistoryNode:
         assert SeedHistoryNode.RETURN_TYPES == ("INT",)
         assert SeedHistoryNode.RETURN_NAMES == ("seed",)
         assert SeedHistoryNode.FUNCTION == "output_seed"
-        assert SeedHistoryNode.CATEGORY == "ComfyAssets/🌱 Seeds"
+        assert SeedHistoryNode.CATEGORY == "🫶 ComfyAssets/🌱 Seeds"
 
     def test_output_seed_valid_input(self):
         """Test seed output with valid input."""

tests/unit/tools/test_width_height_selector.py

@@ -37,7 +37,7 @@ class TestWidthHeightSelectorNode:
         assert self.node.RETURN_TYPES == ("INT", "INT")
         assert self.node.RETURN_NAMES == ("width", "height")
         assert self.node.FUNCTION == "get_dimensions"
-        assert self.node.CATEGORY == "ComfyAssets/🖼️ Resolution"
+        assert self.node.CATEGORY == "🫶 ComfyAssets/🖼️ Resolution"
 
     def test_custom_dimensions(self):
         """Test custom dimensions."""

tests/unit/tools/xyz_helpers/test_flux_sampler_params.py

@@ -182,7 +182,7 @@ class TestFluxSamplerParamsNode:
 
     def test_node_properties(self):
         """Test node properties."""
-        assert FluxSamplerParamsNode.CATEGORY == "ComfyAssets/🧰 xyz-helpers"
+        assert FluxSamplerParamsNode.CATEGORY == "🫶 ComfyAssets/🧰 xyz-helpers"
         assert FluxSamplerParamsNode.FUNCTION == "process_batch"
         assert FluxSamplerParamsNode.RETURN_TYPES == ("LATENT", "SAMPLER_PARAMS")
         assert FluxSamplerParamsNode.RETURN_NAMES == ("latent", "params")

tests/unit/tools/xyz_helpers/test_lora_folder_batch.py

@@ -1,8 +1,9 @@
 """Tests for LoRA Folder Batch node."""
 
 import pytest
-from unittest.mock import Mock, patch, MagicMock
+from unittest.mock import patch, MagicMock
 import os
+import tempfile
 from kikotools.tools.xyz_helpers.lora_folder_batch import LoRAFolderBatchNode
 from kikotools.tools.xyz_helpers.lora_folder_batch.logic import (
     scan_folder_for_loras,
@@ -10,8 +11,8 @@ from kikotools.tools.xyz_helpers.lora_folder_batch.logic import (
     filter_loras_by_pattern,
     parse_strength_string,
     create_lora_params,
+    create_lora_params_batched,
     get_lora_info,
-    validate_folder_path,
 )
 
 
@@ -35,6 +36,27 @@ class TestLoRAFolderBatchLogic:
         # Base file could be first or last depending on implementation
         assert "model-v1.safetensors" in sorted_files
 
+    def test_natural_sort_with_paths(self):
+        """Test natural sorting with subdirectory paths."""
+        files = [
+            "subdir2/model-10.safetensors",
+            "model-2.safetensors",
+            "subdir1/model-20.safetensors",
+            "subdir1/model-3.safetensors",
+            "model-100.safetensors",
+        ]
+        sorted_files = natural_sort(files)
+
+        # Should handle mixed paths and numbers correctly
+        assert len(sorted_files) == 5
+        # Files with smaller numbers should come first within their directories
+        assert sorted_files.index("model-2.safetensors") < sorted_files.index(
+            "model-100.safetensors"
+        )
+        assert sorted_files.index("subdir1/model-3.safetensors") < sorted_files.index(
+            "subdir1/model-20.safetensors"
+        )
+
     def test_filter_loras_by_pattern(self):
         """Test filtering LoRAs by patterns."""
         files = [
@@ -114,6 +136,59 @@ class TestLoRAFolderBatchLogic:
         assert info["epoch"] is None
         assert info["version"] is None
 
+    def test_scan_folder_recursive(self):
+        """Test recursive scanning of LoRA files in subdirectories."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create nested directory structure
+            os.makedirs(os.path.join(temp_dir, "flux", "style"))
+            os.makedirs(os.path.join(temp_dir, "flux", "character"))
+            os.makedirs(os.path.join(temp_dir, "sdxl"))
+
+            # Create test files
+            test_files = [
+                os.path.join(temp_dir, "root-lora.safetensors"),
+                os.path.join(temp_dir, "flux", "flux-lora.safetensors"),
+                os.path.join(temp_dir, "flux", "style", "style-lora.safetensors"),
+                os.path.join(temp_dir, "flux", "character", "char-lora.safetensors"),
+                os.path.join(temp_dir, "sdxl", "sdxl-lora.safetensors"),
+                os.path.join(temp_dir, "not-a-lora.txt"),  # Should be ignored
+            ]
+
+            for file_path in test_files:
+                with open(file_path, "w") as f:
+                    f.write("test")
+
+            # Create a mock folder_paths module
+            mock_folder_paths = MagicMock()
+            mock_folder_paths.folder_names_and_paths = {"loras": [[temp_dir]]}
+
+            # Mock the import
+            import sys
+
+            sys.modules["folder_paths"] = mock_folder_paths
+
+            try:
+                # Test scanning from root - should find all .safetensors files
+                results = scan_folder_for_loras(".")
+                assert len(results) == 5
+                assert "root-lora.safetensors" in results
+                assert "flux/flux-lora.safetensors" in results
+                assert "flux/style/style-lora.safetensors" in results
+                assert "flux/character/char-lora.safetensors" in results
+                assert "sdxl/sdxl-lora.safetensors" in results
+                assert "not-a-lora.txt" not in str(results)
+
+                # Test scanning from subdirectory
+                results = scan_folder_for_loras("flux")
+                assert len(results) == 3
+                assert "flux/flux-lora.safetensors" in results
+                assert "flux/style/style-lora.safetensors" in results
+                assert "flux/character/char-lora.safetensors" in results
+            finally:
+                # Clean up the mock
+                if "folder_paths" in sys.modules:
+                    del sys.modules["folder_paths"]
+
 
 class TestLoRAFolderBatchNode:
     """Test the LoRA Folder Batch node."""
@@ -137,6 +212,9 @@ class TestLoRAFolderBatchNode:
         optional = input_types["optional"]
         assert "include_pattern" in optional
         assert "exclude_pattern" in optional
+        assert "auto_batch" in optional
+        assert "batch_size" in optional
+        assert "batch_index" in optional
 
     def test_batch_loras_empty_folder(self, node):
         """Test with empty folder."""
@@ -183,9 +261,13 @@ class TestLoRAFolderBatchNode:
 
     def test_node_properties(self):
         """Test node properties."""
-        assert LoRAFolderBatchNode.CATEGORY == "ComfyAssets/🧰 xyz-helpers"
+        assert LoRAFolderBatchNode.CATEGORY == "🫶 ComfyAssets/🧰 xyz-helpers"
         assert LoRAFolderBatchNode.FUNCTION == "batch_loras"
-        assert LoRAFolderBatchNode.RETURN_TYPES == ("LORA_PARAMS", "STRING", "INT")
+        assert LoRAFolderBatchNode.RETURN_TYPES == (
+            "LORA_PARAMS",
+            "STRING",
+            "INT",
+        )
         assert LoRAFolderBatchNode.RETURN_NAMES == (
             "lora_params",
             "lora_list",
@@ -200,3 +282,90 @@ class TestLoRAFolderBatchNode:
         time.sleep(0.01)
         result2 = LoRAFolderBatchNode.IS_CHANGED()
         assert result1 != result2
+
+    def test_create_lora_params_batched(self):
+        """Test the batched LoRA params creation."""
+        lora_files = [f"lora_{i:03d}.safetensors" for i in range(75)]
+        strengths = [0.5, 1.0]
+
+        # Test with batch size of 25
+        batches = create_lora_params_batched(lora_files, strengths, "sequential", 25)
+
+        assert len(batches) == 3  # 75 / 25 = 3 batches
+
+        # Check first batch
+        assert len(batches[0]["loras"]) == 25
+        assert batches[0]["batch_info"]["index"] == 0
+        assert batches[0]["batch_info"]["total"] == 3
+        assert batches[0]["batch_info"]["start_idx"] == 0
+        assert batches[0]["batch_info"]["end_idx"] == 25
+        assert batches[0]["batch_info"]["size"] == 25
+
+        # Check second batch
+        assert len(batches[1]["loras"]) == 25
+        assert batches[1]["batch_info"]["index"] == 1
+        assert batches[1]["batch_info"]["start_idx"] == 25
+        assert batches[1]["batch_info"]["end_idx"] == 50
+
+        # Check third batch
+        assert len(batches[2]["loras"]) == 25
+        assert batches[2]["batch_info"]["index"] == 2
+        assert batches[2]["batch_info"]["start_idx"] == 50
+        assert batches[2]["batch_info"]["end_idx"] == 75
+
+    def test_auto_batch_node_integration(self, node):
+        """Test auto-batching in the node."""
+        # Create mock LoRA files
+        lora_files = [f"lora_{i:03d}.safetensors" for i in range(75)]
+
+        with patch(
+            "kikotools.tools.xyz_helpers.lora_folder_batch.node.validate_folder_path"
+        ) as mock_validate:
+            with patch(
+                "kikotools.tools.xyz_helpers.lora_folder_batch.node.scan_folder_for_loras"
+            ) as mock_scan:
+                mock_validate.return_value = True
+                mock_scan.return_value = lora_files
+
+                # Test batch 0
+                params, lora_list, count = node.batch_loras(
+                    folder_path="test",
+                    strength="1.0",
+                    batch_mode="sequential",
+                    auto_batch="enabled",
+                    batch_size=25,
+                    batch_index=0,
+                )
+
+                assert count == 25
+                assert "Batch 1/3" in lora_list
+                assert len(params["loras"]) == 25
+                assert params["loras"][0] == "lora_000.safetensors"
+
+                # Test batch 1
+                params, lora_list, count = node.batch_loras(
+                    folder_path="test",
+                    strength="1.0",
+                    batch_mode="sequential",
+                    auto_batch="enabled",
+                    batch_size=25,
+                    batch_index=1,
+                )
+
+                assert count == 25
+                assert "Batch 2/3" in lora_list
+                assert params["loras"][0] == "lora_025.safetensors"
+
+                # Test batch 2
+                params, lora_list, count = node.batch_loras(
+                    folder_path="test",
+                    strength="1.0",
+                    batch_mode="sequential",
+                    auto_batch="enabled",
+                    batch_size=25,
+                    batch_index=2,
+                )
+
+                assert count == 25
+                assert "Batch 3/3" in lora_list
+                assert params["loras"][0] == "lora_050.safetensors"

tests/unit/tools/xyz_helpers/test_plot_parameters.py

@@ -227,7 +227,7 @@ class TestPlotParametersNode:
 
     def test_node_properties(self):
         """Test node properties."""
-        assert PlotParametersNode.CATEGORY == "ComfyAssets/🧰 xyz-helpers"
+        assert PlotParametersNode.CATEGORY == "🫶 ComfyAssets/🧰 xyz-helpers"
         assert PlotParametersNode.FUNCTION == "plot_parameters"
         assert PlotParametersNode.RETURN_TYPES == ("IMAGE",)
         assert PlotParametersNode.RETURN_NAMES == ("image",)

tests/unit/tools/xyz_helpers/test_sampler_select_helper.py

@@ -85,7 +85,7 @@ class TestSamplerSelectHelperNode:
 
     def test_node_properties(self):
         """Test node properties."""
-        assert SamplerSelectHelperNode.CATEGORY == "ComfyAssets/🧰 xyz-helpers"
+        assert SamplerSelectHelperNode.CATEGORY == "🫶 ComfyAssets/🧰 xyz-helpers"
         assert SamplerSelectHelperNode.FUNCTION == "select_samplers"
         assert SamplerSelectHelperNode.RETURN_TYPES == ("STRING",)
         assert SamplerSelectHelperNode.RETURN_NAMES == ("selected_samplers",)

tests/unit/tools/xyz_helpers/test_scheduler_select_helper.py

@@ -99,7 +99,7 @@ class TestSchedulerSelectHelperNode:
 
     def test_node_properties(self):
         """Test node properties."""
-        assert SchedulerSelectHelperNode.CATEGORY == "ComfyAssets/🧰 xyz-helpers"
+        assert SchedulerSelectHelperNode.CATEGORY == "🫶 ComfyAssets/🧰 xyz-helpers"
         assert SchedulerSelectHelperNode.FUNCTION == "select_schedulers"
         assert SchedulerSelectHelperNode.RETURN_TYPES == ("STRING",)
         assert SchedulerSelectHelperNode.RETURN_NAMES == ("selected_schedulers",)

tests/unit/tools/xyz_helpers/test_text_encode_sampler_params.py

@@ -138,7 +138,7 @@ class TestTextEncodeSamplerParamsNode:
 
     def test_node_properties(self):
         """Test node properties."""
-        assert TextEncodeSamplerParamsNode.CATEGORY == "ComfyAssets/🧰 xyz-helpers"
+        assert TextEncodeSamplerParamsNode.CATEGORY == "🫶 ComfyAssets/🧰 xyz-helpers"
         assert TextEncodeSamplerParamsNode.FUNCTION == "encode_prompts"
         assert TextEncodeSamplerParamsNode.RETURN_TYPES == ("CONDITIONING",)
         assert TextEncodeSamplerParamsNode.RETURN_NAMES == ("conditioning",)

web/display_any.js

@@ -58,13 +58,6 @@ app.registerExtension({
                     }
                 };
                 this.addCustomWidget(copyWidget);
-                
-                // Update node title with condensed info
-                const firstLine = text ? text.split('\n')[0] : '';
-                const condensed = firstLine.length > 50 
-                    ? firstLine.substring(0, 50) + "..." 
-                    : firstLine;
-                this.title = `DisplayAny: ${condensed}`;
 
                 requestAnimationFrame(() => {
                     const sz = this.computeSize();

web/kiko_custom_colors.js

@@ -0,0 +1,258 @@
+import { app } from "../../scripts/app.js";
+import { $el } from "../../scripts/ui.js";
+
+// Custom colors feature with extended options based on PR #433
+// Adds custom color pickers for nodes with full, title, and background options
+
+const colorShade = (col, amt) => {
+    col = col.replace(/^#/, "");
+    if (col.length === 3) col = col[0] + col[0] + col[1] + col[1] + col[2] + col[2];
+
+    let [r, g, b] = col.match(/.{2}/g);
+    [r, g, b] = [parseInt(r, 16) + amt, parseInt(g, 16) + amt, parseInt(b, 16) + amt];
+
+    r = Math.max(Math.min(255, r), 0).toString(16);
+    g = Math.max(Math.min(255, g), 0).toString(16);
+    b = Math.max(Math.min(255, b), 0).toString(16);
+
+    const rr = (r.length < 2 ? "0" : "") + r;
+    const gg = (g.length < 2 ? "0" : "") + g;
+    const bb = (b.length < 2 ? "0" : "") + b;
+
+    return `#${rr}${gg}${bb}`;
+};
+
+app.registerExtension({
+    name: "kikotools.customColors",
+    async init() {
+        // Register settings
+        app.ui.settings.addSetting({
+            id: "kikotools.custom_colors.enabled",
+            name: "🫶 Custom Colors: Enable",
+            type: "boolean",
+            defaultValue: false,
+            tooltip: "Enable custom color picker options in node context menu",
+        });
+
+        app.ui.settings.addSetting({
+            id: "kikotools.custom_colors.show_full",
+            name: "🫶 Custom Colors: Show Full Color Option",
+            type: "boolean",
+            defaultValue: true,
+            tooltip: "Show option to change both title and background colors",
+        });
+
+        app.ui.settings.addSetting({
+            id: "kikotools.custom_colors.show_title",
+            name: "🫶 Custom Colors: Show Title Color Option",
+            type: "boolean",
+            defaultValue: true,
+            tooltip: "Show option to change only title color",
+        });
+
+        app.ui.settings.addSetting({
+            id: "kikotools.custom_colors.show_bg",
+            name: "🫶 Custom Colors: Show Background Color Option",
+            type: "boolean",
+            defaultValue: true,
+            tooltip: "Show option to change only background color",
+        });
+
+        app.ui.settings.addSetting({
+            id: "kikotools.custom_colors.auto_shade",
+            name: "🫶 Custom Colors: Auto-shade Title",
+            type: "boolean",
+            defaultValue: true,
+            tooltip: "Automatically apply shading to title color for better contrast",
+        });
+    },
+
+    setup() {
+        let pickerFull, pickerTitle, pickerBG;
+        let activeNode;
+        
+        // Check if feature is enabled
+        const isEnabled = () => {
+            const setting = app.ui.settings.getSettingValue("kikotools.custom_colors.enabled");
+            return setting !== undefined ? setting : false;
+        };
+
+        const getSettings = () => ({
+            showFull: app.ui.settings.getSettingValue("kikotools.custom_colors.show_full") !== false,
+            showTitle: app.ui.settings.getSettingValue("kikotools.custom_colors.show_title") !== false,
+            showBG: app.ui.settings.getSettingValue("kikotools.custom_colors.show_bg") !== false,
+            autoShade: app.ui.settings.getSettingValue("kikotools.custom_colors.auto_shade") !== false,
+        });
+
+        // Helper function to apply color to node(s)
+        const applyColorToNodes = (colorValue, colorType, node) => {
+            const settings = getSettings();
+            const graphcanvas = LGraphCanvas.active_canvas;
+            const nodes = (!graphcanvas.selected_nodes || Object.keys(graphcanvas.selected_nodes).length <= 1) 
+                ? [node] 
+                : Object.values(graphcanvas.selected_nodes);
+
+            nodes.forEach(n => {
+                if (colorValue) {
+                    if (n.constructor === LiteGraph.LGraphGroup) {
+                        // For groups, only set the main color
+                        if (colorType === 'full' || colorType === 'bg') {
+                            n.color = colorValue;
+                        }
+                    } else {
+                        // For regular nodes
+                        switch(colorType) {
+                            case 'full':
+                                n.color = settings.autoShade ? colorShade(colorValue, 20) : colorValue;
+                                n.bgcolor = colorValue;
+                                break;
+                            case 'title':
+                                n.color = colorValue;
+                                break;
+                            case 'bg':
+                                n.bgcolor = colorValue;
+                                break;
+                        }
+                    }
+                }
+            });
+
+            node.setDirtyCanvas(true, true);
+        };
+
+        // Create color picker input if not exists
+        const createPicker = (type) => {
+            const picker = $el("input", {
+                type: "color",
+                parent: document.body,
+                style: {
+                    display: "none",
+                },
+            });
+            
+            picker.onchange = () => {
+                if (activeNode) {
+                    applyColorToNodes(picker.value, type, activeNode);
+                }
+            };
+            
+            return picker;
+        };
+
+        // Hook into the node colors menu
+        const onMenuNodeColors = LGraphCanvas.onMenuNodeColors;
+        LGraphCanvas.onMenuNodeColors = function (value, options, e, menu, node) {
+            const r = onMenuNodeColors.apply(this, arguments);
+            
+            // Only add custom options if enabled
+            if (!isEnabled()) return r;
+            
+            const settings = getSettings();
+            
+            requestAnimationFrame(() => {
+                const menus = document.querySelectorAll(".litecontextmenu");
+                for (let i = menus.length - 1; i >= 0; i--) {
+                    if (menus[i].firstElementChild.textContent.includes("No color") || 
+                        menus[i].firstElementChild.value?.content?.includes("No color")) {
+                        
+                        // Add Custom Full option
+                        if (settings.showFull) {
+                            $el(
+                                "div.litemenu-entry.submenu",
+                                {
+                                    parent: menus[i],
+                                    $: (el) => {
+                                        el.onclick = () => {
+                                            LiteGraph.closeAllContextMenus();
+                                            if (!pickerFull) {
+                                                pickerFull = createPicker('full');
+                                            }
+                                            activeNode = null;
+                                            pickerFull.value = node.bgcolor || "#000000";
+                                            activeNode = node;
+                                            pickerFull.click();
+                                        };
+                                    },
+                                },
+                                [
+                                    $el("span", {
+                                        style: {
+                                            paddingLeft: "4px",
+                                            display: "block",
+                                        },
+                                        textContent: "🫶 Custom Full",
+                                    }),
+                                ]
+                            );
+                        }
+
+                        // Add Custom Title option
+                        if (settings.showTitle) {
+                            $el(
+                                "div.litemenu-entry.submenu",
+                                {
+                                    parent: menus[i],
+                                    $: (el) => {
+                                        el.onclick = () => {
+                                            LiteGraph.closeAllContextMenus();
+                                            if (!pickerTitle) {
+                                                pickerTitle = createPicker('title');
+                                            }
+                                            activeNode = null;
+                                            pickerTitle.value = node.color || "#000000";
+                                            activeNode = node;
+                                            pickerTitle.click();
+                                        };
+                                    },
+                                },
+                                [
+                                    $el("span", {
+                                        style: {
+                                            paddingLeft: "4px",
+                                            display: "block",
+                                        },
+                                        textContent: "🫶 Custom Title",
+                                    }),
+                                ]
+                            );
+                        }
+
+                        // Add Custom BG option
+                        if (settings.showBG) {
+                            $el(
+                                "div.litemenu-entry.submenu",
+                                {
+                                    parent: menus[i],
+                                    $: (el) => {
+                                        el.onclick = () => {
+                                            LiteGraph.closeAllContextMenus();
+                                            if (!pickerBG) {
+                                                pickerBG = createPicker('bg');
+                                            }
+                                            activeNode = null;
+                                            pickerBG.value = node.bgcolor || "#000000";
+                                            activeNode = node;
+                                            pickerBG.click();
+                                        };
+                                    },
+                                },
+                                [
+                                    $el("span", {
+                                        style: {
+                                            paddingLeft: "4px",
+                                            display: "block",
+                                        },
+                                        textContent: "🫶 Custom BG",
+                                    }),
+                                ]
+                            );
+                        }
+                        
+                        break;
+                    }
+                }
+            });
+            return r;
+        };
+    },
+});

web/kiko_follow_execution.js

@@ -0,0 +1,157 @@
+import { app } from "../../scripts/app.js";
+import { api } from "../../scripts/api.js";
+
+// Adds follow execution feature when enabled in settings
+// Adds menu options to toggle follow execution and go to executing node
+
+app.registerExtension({
+    name: "kikotools.followExecution",
+    async init() {
+        // Register settings in ComfyUI's settings panel
+        app.ui.settings.addSetting({
+            id: "kikotools.follow_execution.enabled",
+            name: "🫶 Follow Execution: Enable",
+            type: "boolean",
+            defaultValue: false,
+            tooltip: "Enable follow execution feature in canvas right-click menu",
+        });
+
+        app.ui.settings.addSetting({
+            id: "kikotools.follow_execution.show_goto_node",
+            name: "🫶 Follow Execution: Show 'Go to node' menu",
+            type: "boolean",
+            defaultValue: true,
+            tooltip: "Show 'Go to node' submenu in canvas menu",
+        });
+
+        app.ui.settings.addSetting({
+            id: "kikotools.follow_execution.auto_start",
+            name: "🫶 Follow Execution: Auto-start",
+            type: "boolean",
+            defaultValue: false,
+            tooltip: "Automatically start following execution when workflow starts",
+        });
+    },
+    
+    async setup() {
+        let followExecution = false;
+        let isEnabled = false;
+
+        // Check if the feature is enabled in settings
+        const checkEnabled = () => {
+            const setting = app.ui.settings.getSettingValue("kikotools.follow_execution.enabled");
+            isEnabled = setting !== undefined ? setting : false;
+            
+            // If disabled, turn off follow execution
+            if (!isEnabled && followExecution) {
+                followExecution = false;
+            }
+        };
+
+        // Check for auto-start setting
+        const checkAutoStart = () => {
+            const autoStart = app.ui.settings.getSettingValue("kikotools.follow_execution.auto_start");
+            if (autoStart && isEnabled) {
+                followExecution = true;
+            }
+        };
+
+        // Initialize settings on startup
+        checkEnabled();
+        checkAutoStart();
+
+        // Center on the executing node
+        const centerNode = (id) => {
+            if (!followExecution || !id || !isEnabled) return;
+            const node = app.graph.getNodeById(id);
+            if (!node) return;
+            app.canvas.centerOnNode(node);
+        };
+
+        // Listen for execution events
+        api.addEventListener("executing", ({ detail }) => centerNode(detail));
+
+        // Listen for execution start to handle auto-start
+        api.addEventListener("execution_start", () => {
+            checkEnabled();
+            checkAutoStart();
+        });
+
+        // Extend canvas menu options
+        const orig = LGraphCanvas.prototype.getCanvasMenuOptions;
+        LGraphCanvas.prototype.getCanvasMenuOptions = function () {
+            const options = orig.apply(this, arguments);
+            
+            // Check if feature is enabled before adding menu items
+            checkEnabled();
+            if (!isEnabled) return options;
+
+            // Add separator
+            options.push(null);
+            
+            // Add follow execution toggle
+            options.push({
+                content: followExecution ? "🫶 Stop following execution" : "🫶 Follow execution",
+                callback: () => {
+                    followExecution = !followExecution;
+                    if (followExecution) {
+                        centerNode(app.runningNodeId);
+                    }
+                },
+            });
+
+            // Add go to executing node option if a node is currently executing
+            if (app.runningNodeId) {
+                options.push({
+                    content: "🫶 Show executing node",
+                    callback: () => {
+                        const node = app.graph.getNodeById(app.runningNodeId);
+                        if (!node) return;
+                        app.canvas.centerOnNode(node);
+                    },
+                });
+            }
+
+            // Add go to node by type submenu
+            const showGoToNode = app.ui.settings.getSettingValue("kikotools.follow_execution.show_goto_node");
+            if (showGoToNode !== false) {  // Default to true if not set
+                const nodes = app.graph._nodes;
+                const types = nodes.reduce((p, n) => {
+                    if (n.type in p) {
+                        p[n.type].push(n);
+                    } else {
+                        p[n.type] = [n];
+                    }
+                    return p;
+                }, {});
+
+                options.push({
+                    content: "🫶 Go to node",
+                    has_submenu: true,
+                    submenu: {
+                        options: Object.keys(types)
+                            .sort()
+                            .map((t) => ({
+                                content: t,
+                                has_submenu: true,
+                                submenu: {
+                                    options: types[t]
+                                        .sort((a, b) => {
+                                            return a.pos[0] - b.pos[0];
+                                        })
+                                        .map((n) => ({
+                                            content: `${n.getTitle()} - #${n.id} (${Math.round(n.pos[0])}, ${Math.round(n.pos[1])})`,
+                                            callback: () => {
+                                                app.canvas.centerOnNode(n);
+                                            },
+                                        })),
+                                },
+                            })),
+                    },
+                });
+            }
+
+            return options;
+        };
+    },
+});