Update release notes and version to v0.8.14: add virtualized scrolling, compact display mode, and enhanced LoRA node functionality.

Add virtual scroll

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+ko_fi: pixelpawsai
+custom: ['paypal.me/pixelpawsai']

README.md

@@ -20,6 +20,24 @@ Watch this quick tutorial to learn how to use the new one-click LoRA integration
 
 ## Release Notes
 
+### v0.8.14
+* **Virtualized Scrolling** - Completely rebuilt rendering mechanism for smooth browsing with no lag or freezing, now supporting virtually unlimited model collections with optimized layouts for large displays, improving space utilization and user experience
+* **Compact Display Mode** - Added space-efficient view option that displays more cards per row (7 on 1080p, 8 on 2K, 10 on 4K)
+* **Enhanced LoRA Node Functionality** - Comprehensive improvements to LoRA loader/stacker nodes including real-time trigger word updates (reflecting any change anywhere in the LoRA chain for precise updates) and expanded context menu with "Copy Notes" and "Copy Trigger Words" options for faster workflow
+
+### v0.8.13
+* **Enhanced Recipe Management** - Added "Find duplicates" feature to identify and batch delete duplicate recipes with duplicate detection notifications during imports
+* **Improved Source Tracking** - Source URLs are now saved with recipes imported via URL, allowing users to view original content with one click or manually edit links
+* **Advanced LoRA Control** - Double-click LoRAs in Loader/Stacker nodes to access expanded CLIP strength controls for more precise adjustments of model and CLIP strength separately
+* **Lycoris Model Support** - Added compatibility with Lycoris models for expanded creative options
+* **Bug Fixes & UX Improvements** - Resolved various issues and enhanced overall user experience with numerous optimizations
+
+### v0.8.12
+* **Enhanced Model Discovery** - Added alphabetical navigation bar to LoRAs page for faster browsing through large collections
+* **Optimized Example Images** - Improved download logic to automatically refresh stale metadata before fetching example images
+* **Model Exclusion System** - New right-click option to exclude specific LoRAs or checkpoints from management
+* **Improved Showcase Experience** - Enhanced interaction in LoRA and checkpoint showcase areas for better usability
+
 ### v0.8.11
 * **Offline Image Support** - Added functionality to download and save all model example images locally, ensuring access even when offline or if images are removed from CivitAI or the site is down
 * **Resilient Download System** - Implemented pause/resume capability with checkpoint recovery that persists through restarts or unexpected exits
@@ -283,6 +301,8 @@ If you find this project helpful, consider supporting its development:
 
 [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/pixelpawsai)
 
+WeChat: [Click to view QR code](https://raw.githubusercontent.com/willmiao/ComfyUI-Lora-Manager/main/static/images/wechat-qr.webp)
+
 ## 💬 Community
 
 Join our Discord community for support, discussions, and updates:

py/metadata_collector/metadata_processor.py

@@ -187,19 +187,36 @@ class MetadataProcessor:
                         sampler_params = metadata[SAMPLING][sampler_node_id].get("parameters", {})
                         params["sampler"] = sampler_params.get("sampler_name")
                     
-                    # 3. Trace guider input for FluxGuidance and CLIPTextEncode
+                    # 3. Trace guider input for CFGGuider, FluxGuidance and CLIPTextEncode
                     guider_node_id = MetadataProcessor.trace_node_input(prompt, primary_sampler_id, "guider", max_depth=5)
-                    if guider_node_id:
-                        # Look for FluxGuidance along the guider path
-                        flux_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", "FluxGuidance", max_depth=5)
-                        if flux_node_id and flux_node_id in metadata.get(SAMPLING, {}):
-                            flux_params = metadata[SAMPLING][flux_node_id].get("parameters", {})
-                            params["guidance"] = flux_params.get("guidance")
-                        
-                        # Find CLIPTextEncode for positive prompt (through conditioning)
-                        positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", "CLIPTextEncode", max_depth=10)
-                        if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
-                            params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
+                    if guider_node_id and guider_node_id in prompt.original_prompt:
+                        # Check if the guider node is a CFGGuider
+                        if prompt.original_prompt[guider_node_id].get("class_type") == "CFGGuider":
+                            # Extract cfg value from the CFGGuider
+                            if guider_node_id in metadata.get(SAMPLING, {}):
+                                cfg_params = metadata[SAMPLING][guider_node_id].get("parameters", {})
+                                params["cfg_scale"] = cfg_params.get("cfg")
+                            
+                            # Find CLIPTextEncode for positive prompt
+                            positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "positive", "CLIPTextEncode", max_depth=10)
+                            if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
+                                params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
+                            
+                            # Find CLIPTextEncode for negative prompt
+                            negative_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "negative", "CLIPTextEncode", max_depth=10)
+                            if negative_node_id and negative_node_id in metadata.get(PROMPTS, {}):
+                                params["negative_prompt"] = metadata[PROMPTS][negative_node_id].get("text", "")
+                        else:
+                            # Look for FluxGuidance along the guider path
+                            flux_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", "FluxGuidance", max_depth=5)
+                            if flux_node_id and flux_node_id in metadata.get(SAMPLING, {}):
+                                flux_params = metadata[SAMPLING][flux_node_id].get("parameters", {})
+                                params["guidance"] = flux_params.get("guidance")
+                            
+                            # Find CLIPTextEncode for positive prompt (through conditioning)
+                            positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", "CLIPTextEncode", max_depth=10)
+                            if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
+                                params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
                 
                 else:
                     # Original tracing for standard samplers

py/metadata_collector/node_extractors.py

@@ -362,6 +362,23 @@ class CLIPTextEncodeFluxExtractor(NodeMetadataExtractor):
                 
             metadata[SAMPLING][node_id]["parameters"]["guidance"] = guidance_value
 
+class CFGGuiderExtractor(NodeMetadataExtractor):
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs or "cfg" not in inputs:
+            return
+            
+        cfg_value = inputs.get("cfg")
+        
+        # Store the cfg value in SAMPLING category
+        if SAMPLING not in metadata:
+            metadata[SAMPLING] = {}
+            
+        if node_id not in metadata[SAMPLING]:
+            metadata[SAMPLING][node_id] = {"parameters": {}, "node_id": node_id}
+            
+        metadata[SAMPLING][node_id]["parameters"]["cfg"] = cfg_value
+
 # Registry of node-specific extractors
 NODE_EXTRACTORS = {
     # Sampling
@@ -383,6 +400,7 @@ NODE_EXTRACTORS = {
     "EmptyLatentImage": ImageSizeExtractor,
     # Flux
     "FluxGuidance": FluxGuidanceExtractor,      # Add FluxGuidance
+    "CFGGuider": CFGGuiderExtractor,            # Add CFGGuider
     # Image
     "VAEDecode": VAEDecodeExtractor,  # Added VAEDecode extractor
     # Add other nodes as needed

py/nodes/lora_loader.py

@@ -1,10 +1,7 @@
 import logging
 from nodes import LoraLoader
 from comfy.comfy_types import IO # type: ignore
-from ..services.lora_scanner import LoraScanner
-from ..config import config
 import asyncio
-import os
 from .utils import FlexibleOptionalInputType, any_type, get_lora_info, extract_lora_name, get_loras_list
 
 logger = logging.getLogger(__name__)
@@ -51,7 +48,11 @@ class LoraManagerLoader:
                 _, trigger_words = asyncio.run(get_lora_info(lora_name))
                 
                 all_trigger_words.extend(trigger_words)
-                loaded_loras.append(f"{lora_name}: {model_strength}")
+                # Add clip strength to output if different from model strength
+                if abs(model_strength - clip_strength) > 0.001:
+                    loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+                else:
+                    loaded_loras.append(f"{lora_name}: {model_strength}")
         
         # Then process loras from kwargs with support for both old and new formats
         loras_list = get_loras_list(kwargs)
@@ -60,14 +61,21 @@ class LoraManagerLoader:
                 continue
                 
             lora_name = lora['name']
-            strength = float(lora['strength'])
+            model_strength = float(lora['strength'])
+            # Get clip strength - use model strength as default if not specified
+            clip_strength = float(lora.get('clipStrength', model_strength))
             
             # Get lora path and trigger words
             lora_path, trigger_words = asyncio.run(get_lora_info(lora_name))
             
-            # Apply the LoRA using the resolved path
-            model, clip = LoraLoader().load_lora(model, clip, lora_path, strength, strength)
-            loaded_loras.append(f"{lora_name}: {strength}")
+            # Apply the LoRA using the resolved path with separate strengths
+            model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+            
+            # Include clip strength in output if different from model strength
+            if abs(model_strength - clip_strength) > 0.001:
+                loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+            else:
+                loaded_loras.append(f"{lora_name}: {model_strength}")
             
             # Add trigger words to collection
             all_trigger_words.extend(trigger_words)
@@ -75,8 +83,23 @@ class LoraManagerLoader:
         # use ',, ' to separate trigger words for group mode
         trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
         
-        # Format loaded_loras as <lora:lora_name:strength> separated by spaces
-        formatted_loras = " ".join([f"<lora:{name.split(':')[0].strip()}:{str(strength).strip()}>" 
-                                  for name, strength in [item.split(':') for item in loaded_loras]])
+        # Format loaded_loras with support for both formats
+        formatted_loras = []
+        for item in loaded_loras:
+            parts = item.split(":")
+            lora_name = parts[0].strip()
+            strength_parts = parts[1].strip().split(",")
+            
+            if len(strength_parts) > 1:
+                # Different model and clip strengths
+                model_str = strength_parts[0].strip()
+                clip_str = strength_parts[1].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}:{clip_str}>")
+            else:
+                # Same strength for both
+                model_str = strength_parts[0].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}>")
+                
+        formatted_loras_text = " ".join(formatted_loras)
 
-        return (model, clip, trigger_words_text, formatted_loras)
+        return (model, clip, trigger_words_text, formatted_loras_text)

py/nodes/lora_stacker.py

@@ -38,7 +38,7 @@ class LoraStacker:
         
         # Process existing lora_stack if available
         lora_stack = kwargs.get('lora_stack', None)
-        if lora_stack:
+        if (lora_stack):
             stack.extend(lora_stack)
             # Get trigger words from existing stack entries
             for lora_path, _, _ in lora_stack:
@@ -54,7 +54,8 @@ class LoraStacker:
                 
             lora_name = lora['name']
             model_strength = float(lora['strength'])
-            clip_strength = model_strength  # Using same strength for both as in the original loader
+            # Get clip strength - use model strength as default if not specified
+            clip_strength = float(lora.get('clipStrength', model_strength))
             
             # Get lora path and trigger words
             lora_path, trigger_words = asyncio.run(get_lora_info(lora_name))
@@ -62,15 +63,24 @@ class LoraStacker:
             # Add to stack without loading
             # replace '/' with os.sep to avoid different OS path format
             stack.append((lora_path.replace('/', os.sep), model_strength, clip_strength))
-            active_loras.append((lora_name, model_strength))
+            active_loras.append((lora_name, model_strength, clip_strength))
             
             # Add trigger words to collection
             all_trigger_words.extend(trigger_words)
         
         # use ',, ' to separate trigger words for group mode
         trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
-        # Format active_loras as <lora:lora_name:strength> separated by spaces
-        active_loras_text = " ".join([f"<lora:{name}:{str(strength).strip()}>" 
-                                  for name, strength in active_loras])
+        
+        # Format active_loras with support for both formats
+        formatted_loras = []
+        for name, model_strength, clip_strength in active_loras:
+            if abs(model_strength - clip_strength) > 0.001:
+                # Different model and clip strengths
+                formatted_loras.append(f"<lora:{name}:{str(model_strength).strip()}:{str(clip_strength).strip()}>")
+            else:
+                # Same strength for both
+                formatted_loras.append(f"<lora:{name}:{str(model_strength).strip()}>")
+                
+        active_loras_text = " ".join(formatted_loras)
 
         return (stack, trigger_words_text, active_loras_text)

py/recipes/__init__.py

@@ -0,0 +1,22 @@
+"""Recipe metadata parser package for ComfyUI-Lora-Manager."""
+
+from .base import RecipeMetadataParser
+from .factory import RecipeParserFactory
+from .constants import GEN_PARAM_KEYS, VALID_LORA_TYPES
+from .parsers import (
+    RecipeFormatParser,
+    ComfyMetadataParser,
+    MetaFormatParser,
+    AutomaticMetadataParser
+)
+
+__all__ = [
+    'RecipeMetadataParser',
+    'RecipeParserFactory',
+    'GEN_PARAM_KEYS',
+    'VALID_LORA_TYPES',
+    'RecipeFormatParser',
+    'ComfyMetadataParser',
+    'MetaFormatParser',
+    'AutomaticMetadataParser'
+]

py/recipes/base.py

@@ -0,0 +1,181 @@
+"""Base classes for recipe parsers."""
+
+import json
+import logging
+import os
+import re
+from typing import Dict, List, Any, Optional, Tuple
+from abc import ABC, abstractmethod
+from ..config import config
+from .constants import VALID_LORA_TYPES
+
+logger = logging.getLogger(__name__)
+
+class RecipeMetadataParser(ABC):
+    """Interface for parsing recipe metadata from image user comments"""
+
+    METADATA_MARKER = None
+
+    @abstractmethod
+    def is_metadata_matching(self, user_comment: str) -> bool:
+        """Check if the user comment matches the metadata format"""
+        pass
+    
+    @abstractmethod
+    async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
+        """
+        Parse metadata from user comment and return structured recipe data
+        
+        Args:
+            user_comment: The EXIF UserComment string from the image
+            recipe_scanner: Optional recipe scanner instance for local LoRA lookup
+            civitai_client: Optional Civitai client for fetching model information
+            
+        Returns:
+            Dict containing parsed recipe data with standardized format
+        """
+        pass
+    
+    async def populate_lora_from_civitai(self, lora_entry: Dict[str, Any], civitai_info_tuple: Tuple[Dict[str, Any], Optional[str]], 
+                                         recipe_scanner=None, base_model_counts=None, hash_value=None) -> Optional[Dict[str, Any]]:
+        """
+        Populate a lora entry with information from Civitai API response
+        
+        Args:
+            lora_entry: The lora entry to populate
+            civitai_info_tuple: The response tuple from Civitai API (data, error_msg)
+            recipe_scanner: Optional recipe scanner for local file lookup
+            base_model_counts: Optional dict to track base model counts
+            hash_value: Optional hash value to use if not available in civitai_info
+            
+        Returns:
+            The populated lora_entry dict if type is valid, None otherwise
+        """
+        try:
+            # Unpack the tuple to get the actual data
+            civitai_info, error_msg = civitai_info_tuple if isinstance(civitai_info_tuple, tuple) else (civitai_info_tuple, None)
+            
+            if not civitai_info or civitai_info.get("error") == "Model not found":
+                # Model not found or deleted
+                lora_entry['isDeleted'] = True
+                lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
+                return lora_entry
+                
+            # Get model type and validate
+            model_type = civitai_info.get('model', {}).get('type', '').lower()
+            lora_entry['type'] = model_type
+            if model_type not in VALID_LORA_TYPES:
+                logger.debug(f"Skipping non-LoRA model type: {model_type}")
+                return None
+
+            # Check if this is an early access lora
+            if civitai_info.get('earlyAccessEndsAt'):
+                # Convert earlyAccessEndsAt to a human-readable date
+                early_access_date = civitai_info.get('earlyAccessEndsAt', '')
+                lora_entry['isEarlyAccess'] = True
+                lora_entry['earlyAccessEndsAt'] = early_access_date
+                
+            # Update model name if available
+            if 'model' in civitai_info and 'name' in civitai_info['model']:
+                lora_entry['name'] = civitai_info['model']['name']
+            
+            # Update version if available
+            if 'name' in civitai_info:
+                lora_entry['version'] = civitai_info.get('name', '')
+            
+            # Get thumbnail URL from first image
+            if 'images' in civitai_info and civitai_info['images']:
+                lora_entry['thumbnailUrl'] = civitai_info['images'][0].get('url', '')
+            
+            # Get base model
+            current_base_model = civitai_info.get('baseModel', '')
+            lora_entry['baseModel'] = current_base_model
+            
+            # Update base model counts if tracking them
+            if base_model_counts is not None and current_base_model:
+                base_model_counts[current_base_model] = base_model_counts.get(current_base_model, 0) + 1
+            
+            # Get download URL
+            lora_entry['downloadUrl'] = civitai_info.get('downloadUrl', '')
+            
+            # Process file information if available
+            if 'files' in civitai_info:
+                # Find the primary model file (type="Model" and primary=true) in the files list
+                model_file = next((file for file in civitai_info.get('files', []) 
+                                    if file.get('type') == 'Model' and file.get('primary') == True), None)
+                
+                if model_file:
+                    # Get size
+                    lora_entry['size'] = model_file.get('sizeKB', 0) * 1024
+                    
+                    # Get SHA256 hash
+                    sha256 = model_file.get('hashes', {}).get('SHA256', hash_value)
+                    if sha256:
+                        lora_entry['hash'] = sha256.lower()
+                    
+                    # Check if exists locally
+                    if recipe_scanner and lora_entry['hash']:
+                        lora_scanner = recipe_scanner._lora_scanner
+                        exists_locally = lora_scanner.has_lora_hash(lora_entry['hash'])
+                        if exists_locally:
+                            try:
+                                local_path = lora_scanner.get_lora_path_by_hash(lora_entry['hash'])
+                                lora_entry['existsLocally'] = True
+                                lora_entry['localPath'] = local_path
+                                lora_entry['file_name'] = os.path.splitext(os.path.basename(local_path))[0]
+                                
+                                # Get thumbnail from local preview if available
+                                lora_cache = await lora_scanner.get_cached_data()
+                                lora_item = next((item for item in lora_cache.raw_data 
+                                                    if item['sha256'].lower() == lora_entry['hash'].lower()), None)
+                                if lora_item and 'preview_url' in lora_item:
+                                    lora_entry['thumbnailUrl'] = config.get_preview_static_url(lora_item['preview_url'])
+                            except Exception as e:
+                                logger.error(f"Error getting local lora path: {e}")
+                        else:
+                            # For missing LoRAs, get file_name from model_file.name
+                            file_name = model_file.get('name', '')
+                            lora_entry['file_name'] = os.path.splitext(file_name)[0] if file_name else ''
+                
+        except Exception as e:
+            logger.error(f"Error populating lora from Civitai info: {e}")
+            
+        return lora_entry
+        
+    async def populate_checkpoint_from_civitai(self, checkpoint: Dict[str, Any], civitai_info: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Populate checkpoint information from Civitai API response
+        
+        Args:
+            checkpoint: The checkpoint entry to populate
+            civitai_info: The response from Civitai API
+            
+        Returns:
+            The populated checkpoint dict
+        """
+        try:
+            if civitai_info and civitai_info.get("error") != "Model not found":
+                # Update model name if available
+                if 'model' in civitai_info and 'name' in civitai_info['model']:
+                    checkpoint['name'] = civitai_info['model']['name']
+                
+                # Update version if available
+                if 'name' in civitai_info:
+                    checkpoint['version'] = civitai_info.get('name', '')
+                
+                # Get thumbnail URL from first image
+                if 'images' in civitai_info and civitai_info['images']:
+                    checkpoint['thumbnailUrl'] = civitai_info['images'][0].get('url', '')
+                
+                # Get base model
+                checkpoint['baseModel'] = civitai_info.get('baseModel', '')
+                
+                # Get download URL
+                checkpoint['downloadUrl'] = civitai_info.get('downloadUrl', '')
+            else:
+                # Model not found or deleted
+                checkpoint['isDeleted'] = True
+        except Exception as e:
+            logger.error(f"Error populating checkpoint from Civitai info: {e}")
+            
+        return checkpoint

py/recipes/constants.py

@@ -0,0 +1,16 @@
+"""Constants used across recipe parsers."""
+
+# Constants for generation parameters
+GEN_PARAM_KEYS = [
+    'prompt',
+    'negative_prompt', 
+    'steps',
+    'sampler',
+    'cfg_scale',
+    'seed',
+    'size',
+    'clip_skip',
+]
+
+# Valid Lora types
+VALID_LORA_TYPES = ['lora', 'locon']

py/recipes/factory.py

@@ -0,0 +1,43 @@
+"""Factory for creating recipe metadata parsers."""
+
+import logging
+from .parsers import (
+    RecipeFormatParser,
+    ComfyMetadataParser,
+    MetaFormatParser,
+    AutomaticMetadataParser
+)
+from .base import RecipeMetadataParser
+
+logger = logging.getLogger(__name__)
+
+class RecipeParserFactory:
+    """Factory for creating recipe metadata parsers"""
+    
+    @staticmethod
+    def create_parser(user_comment: str) -> RecipeMetadataParser:
+        """
+        Create appropriate parser based on the user comment content
+        
+        Args:
+            user_comment: The EXIF UserComment string from the image
+            
+        Returns:
+            Appropriate RecipeMetadataParser implementation
+        """
+        # Try ComfyMetadataParser first since it requires valid JSON
+        try:
+            if ComfyMetadataParser().is_metadata_matching(user_comment):
+                return ComfyMetadataParser()
+        except Exception:
+            # If JSON parsing fails, move on to other parsers
+            pass
+            
+        if RecipeFormatParser().is_metadata_matching(user_comment):
+            return RecipeFormatParser()
+        elif AutomaticMetadataParser().is_metadata_matching(user_comment):
+            return AutomaticMetadataParser()
+        elif MetaFormatParser().is_metadata_matching(user_comment):
+            return MetaFormatParser()
+        else:
+            return None

py/recipes/parsers/__init__.py

@@ -0,0 +1,13 @@
+"""Recipe parsers package."""
+
+from .recipe_format import RecipeFormatParser
+from .comfy import ComfyMetadataParser
+from .meta_format import MetaFormatParser
+from .automatic import AutomaticMetadataParser
+
+__all__ = [
+    'RecipeFormatParser',
+    'ComfyMetadataParser',
+    'MetaFormatParser',
+    'AutomaticMetadataParser',
+]

py/recipes/parsers/automatic.py

@@ -0,0 +1,304 @@
+"""Parser for Automatic1111 metadata format."""
+
+import re
+import json
+import logging
+from typing import Dict, Any
+from ..base import RecipeMetadataParser
+from ..constants import GEN_PARAM_KEYS
+
+logger = logging.getLogger(__name__)
+
+class AutomaticMetadataParser(RecipeMetadataParser):
+    """Parser for Automatic1111 metadata format"""
+    
+    METADATA_MARKER = r"Steps: \d+"
+    
+    # Regular expressions for extracting specific metadata
+    HASHES_REGEX = r', Hashes:\s*({[^}]+})'
+    LORA_HASHES_REGEX = r', Lora hashes:\s*"([^"]+)"'
+    CIVITAI_RESOURCES_REGEX = r', Civitai resources:\s*(\[\{.*?\}\])'
+    CIVITAI_METADATA_REGEX = r', Civitai metadata:\s*(\{.*?\})'
+    EXTRANETS_REGEX = r'<(lora|hypernet):([a-zA-Z0-9_\.\-]+):([0-9.]+)>'
+    MODEL_HASH_PATTERN = r'Model hash: ([a-zA-Z0-9]+)'
+    VAE_HASH_PATTERN = r'VAE hash: ([a-zA-Z0-9]+)'
+    
+    def is_metadata_matching(self, user_comment: str) -> bool:
+        """Check if the user comment matches the Automatic1111 format"""
+        return re.search(self.METADATA_MARKER, user_comment) is not None
+    
+    async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
+        """Parse metadata from Automatic1111 format"""
+        try:
+            # Split on Negative prompt if it exists
+            if "Negative prompt:" in user_comment:
+                parts = user_comment.split('Negative prompt:', 1)
+                prompt = parts[0].strip()
+                negative_and_params = parts[1] if len(parts) > 1 else ""
+            else:
+                # No negative prompt section
+                param_start = re.search(self.METADATA_MARKER, user_comment)
+                if param_start:
+                    prompt = user_comment[:param_start.start()].strip()
+                    negative_and_params = user_comment[param_start.start():]
+                else:
+                    prompt = user_comment.strip()
+                    negative_and_params = ""
+            
+            # Initialize metadata
+            metadata = {
+                "prompt": prompt,
+                "loras": []
+            }
+            
+            # Extract negative prompt and parameters
+            if negative_and_params:
+                # If we split on "Negative prompt:", check for params section
+                if "Negative prompt:" in user_comment:
+                    param_start = re.search(r'Steps: ', negative_and_params)
+                    if param_start:
+                        neg_prompt = negative_and_params[:param_start.start()].strip()
+                        metadata["negative_prompt"] = neg_prompt
+                        params_section = negative_and_params[param_start.start():]
+                    else:
+                        metadata["negative_prompt"] = negative_and_params.strip()
+                        params_section = ""
+                else:
+                    # No negative prompt, entire section is params
+                    params_section = negative_and_params
+                
+                # Extract generation parameters
+                if params_section:
+                    # Extract Civitai resources
+                    civitai_resources_match = re.search(self.CIVITAI_RESOURCES_REGEX, params_section)
+                    if civitai_resources_match:
+                        try:
+                            civitai_resources = json.loads(civitai_resources_match.group(1))
+                            metadata["civitai_resources"] = civitai_resources
+                            params_section = params_section.replace(civitai_resources_match.group(0), '')
+                        except json.JSONDecodeError:
+                            logger.error("Error parsing Civitai resources JSON")
+                    
+                    # Extract Hashes
+                    hashes_match = re.search(self.HASHES_REGEX, params_section)
+                    if hashes_match:
+                        try:
+                            hashes = json.loads(hashes_match.group(1))
+                            # Process hash keys
+                            processed_hashes = {}
+                            for key, value in hashes.items():
+                                # Convert Model: or LORA: prefix to lowercase if present
+                                if ':' in key:
+                                    prefix, name = key.split(':', 1)
+                                    prefix = prefix.lower()
+                                else:
+                                    prefix = ''
+                                    name = key
+
+                                # Clean up the name part
+                                if '/' in name:
+                                    name = name.split('/')[-1]  # Get last part after /
+                                if '.safetensors' in name:
+                                    name = name.split('.safetensors')[0]  # Remove .safetensors
+                                
+                                # Reconstruct the key
+                                new_key = f"{prefix}:{name}" if prefix else name
+                                processed_hashes[new_key] = value
+
+                            metadata["hashes"] = processed_hashes
+                            # Remove hashes from params section to not interfere with other parsing
+                            params_section = params_section.replace(hashes_match.group(0), '')
+                        except json.JSONDecodeError:
+                            logger.error("Error parsing hashes JSON")
+                    
+                    # Extract Lora hashes in alternative format
+                    lora_hashes_match = re.search(self.LORA_HASHES_REGEX, params_section)
+                    if not hashes_match and lora_hashes_match:
+                        try:
+                            lora_hashes_str = lora_hashes_match.group(1)
+                            lora_hash_entries = lora_hashes_str.split(', ')
+                            
+                            # Initialize hashes dict if it doesn't exist
+                            if "hashes" not in metadata:
+                                metadata["hashes"] = {}
+                                
+                            # Parse each lora hash entry (format: "name: hash")
+                            for entry in lora_hash_entries:
+                                if ': ' in entry:
+                                    lora_name, lora_hash = entry.split(': ', 1)
+                                    # Add as lora type in the same format as regular hashes
+                                    metadata["hashes"][f"lora:{lora_name}"] = lora_hash.strip()
+                            
+                            # Remove lora hashes from params section
+                            params_section = params_section.replace(lora_hashes_match.group(0), '')
+                        except Exception as e:
+                            logger.error(f"Error parsing Lora hashes: {e}")
+                    
+                    # Extract basic parameters
+                    param_pattern = r'([A-Za-z\s]+): ([^,]+)'
+                    params = re.findall(param_pattern, params_section)
+                    gen_params = {}
+                    
+                    for key, value in params:
+                        clean_key = key.strip().lower().replace(' ', '_')
+                        
+                        # Skip if not in recognized gen param keys
+                        if clean_key not in GEN_PARAM_KEYS:
+                            continue
+                            
+                        # Convert numeric values
+                        if clean_key in ['steps', 'seed']:
+                            try:
+                                gen_params[clean_key] = int(value.strip())
+                            except ValueError:
+                                gen_params[clean_key] = value.strip()
+                        elif clean_key in ['cfg_scale']:
+                            try:
+                                gen_params[clean_key] = float(value.strip())
+                            except ValueError:
+                                gen_params[clean_key] = value.strip()
+                        else:
+                            gen_params[clean_key] = value.strip()
+                    
+                    # Extract size if available and add to gen_params if a recognized key
+                    size_match = re.search(r'Size: (\d+)x(\d+)', params_section)
+                    if size_match and 'size' in GEN_PARAM_KEYS:
+                        width, height = size_match.groups()
+                        gen_params['size'] = f"{width}x{height}"
+                    
+                    # Add prompt and negative_prompt to gen_params if they're in GEN_PARAM_KEYS
+                    if 'prompt' in GEN_PARAM_KEYS and 'prompt' in metadata:
+                        gen_params['prompt'] = metadata['prompt']
+                    if 'negative_prompt' in GEN_PARAM_KEYS and 'negative_prompt' in metadata:
+                        gen_params['negative_prompt'] = metadata['negative_prompt']
+                    
+                    metadata["gen_params"] = gen_params
+            
+            # Extract LoRA information 
+            loras = []
+            base_model_counts = {}
+            
+            # First use Civitai resources if available (more reliable source)
+            if metadata.get("civitai_resources"):
+                for resource in metadata.get("civitai_resources", []):
+                    if resource.get("type") in ["lora", "lycoris", "hypernet"] and resource.get("modelVersionId"):
+                        # Initialize lora entry
+                        lora_entry = {
+                            'id': str(resource.get("modelVersionId")),
+                            'modelId': str(resource.get("modelId")) if resource.get("modelId") else None,
+                            'name': resource.get("modelName", "Unknown LoRA"),
+                            'version': resource.get("modelVersionName", ""),
+                            'type': resource.get("type", "lora"),
+                            'weight': round(float(resource.get("weight", 1.0)), 2),
+                            'existsLocally': False,
+                            'thumbnailUrl': '/loras_static/images/no-preview.png',
+                            'baseModel': '',
+                            'size': 0,
+                            'downloadUrl': '',
+                            'isDeleted': False
+                        }
+                        
+                        # Get additional info from Civitai
+                        if civitai_client:
+                            try:
+                                civitai_info = await civitai_client.get_model_version_info(resource.get("modelVersionId"))
+                                populated_entry = await self.populate_lora_from_civitai(
+                                    lora_entry,
+                                    civitai_info,
+                                    recipe_scanner,
+                                    base_model_counts
+                                )
+                                if populated_entry is None:
+                                    continue  # Skip invalid LoRA types
+                                lora_entry = populated_entry
+                            except Exception as e:
+                                logger.error(f"Error fetching Civitai info for LoRA {lora_entry['name']}: {e}")
+                        
+                        loras.append(lora_entry)
+            
+            # If no LoRAs from Civitai resources or to supplement, extract from metadata["hashes"]
+            if not loras or len(loras) == 0:
+                # Extract lora weights from extranet tags in prompt (for later use)
+                lora_weights = {}
+                lora_matches = re.findall(self.EXTRANETS_REGEX, prompt)
+                for lora_type, lora_name, lora_weight in lora_matches:
+                    key = f"{lora_type}:{lora_name}"
+                    lora_weights[key] = round(float(lora_weight), 2)
+                
+                # Use hashes from metadata as the primary source
+                if metadata.get("hashes"):
+                    for hash_key, lora_hash in metadata.get("hashes", {}).items():
+                        # Only process lora or hypernet types
+                        if not hash_key.startswith(("lora:", "hypernet:")):
+                            continue
+                            
+                        lora_type, lora_name = hash_key.split(':', 1)
+                        
+                        # Get weight from extranet tags if available, else default to 1.0
+                        weight = lora_weights.get(hash_key, 1.0)
+                        
+                        # Initialize lora entry
+                        lora_entry = {
+                            'name': lora_name,
+                            'type': lora_type,  # 'lora' or 'hypernet'
+                            'weight': weight,
+                            'hash': lora_hash,
+                            'existsLocally': False,
+                            'localPath': None,
+                            'file_name': lora_name,
+                            'thumbnailUrl': '/loras_static/images/no-preview.png',
+                            'baseModel': '',
+                            'size': 0,
+                            'downloadUrl': '',
+                            'isDeleted': False
+                        }
+                        
+                        # Try to get info from Civitai
+                        if civitai_client:
+                            try:
+                                if lora_hash:
+                                    # If we have hash, use it for lookup
+                                    civitai_info = await civitai_client.get_model_by_hash(lora_hash)
+                                else:
+                                    civitai_info = None
+                                
+                                populated_entry = await self.populate_lora_from_civitai(
+                                    lora_entry, 
+                                    civitai_info, 
+                                    recipe_scanner,
+                                    base_model_counts,
+                                    lora_hash
+                                )
+                                if populated_entry is None:
+                                    continue  # Skip invalid LoRA types
+                                lora_entry = populated_entry
+                            except Exception as e:
+                                logger.error(f"Error fetching Civitai info for LoRA {lora_name}: {e}")
+                        
+                        loras.append(lora_entry)
+                
+            # Try to get base model from resources or make educated guess
+            base_model = None
+            if base_model_counts:
+                # Use the most common base model from the loras
+                base_model = max(base_model_counts.items(), key=lambda x: x[1])[0]
+            
+            # Prepare final result structure
+            # Make sure gen_params only contains recognized keys
+            filtered_gen_params = {}
+            for key in GEN_PARAM_KEYS:
+                if key in metadata.get("gen_params", {}):
+                    filtered_gen_params[key] = metadata["gen_params"][key]
+            
+            result = {
+                'base_model': base_model,
+                'loras': loras,
+                'gen_params': filtered_gen_params,
+                'from_automatic_metadata': True
+            }
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error parsing Automatic1111 metadata: {e}", exc_info=True)
+            return {"error": str(e), "loras": []}

py/recipes/parsers/comfy.py

@@ -0,0 +1,216 @@
+"""Parser for ComfyUI metadata format."""
+
+import re
+import json
+import logging
+from typing import Dict, Any
+from ..base import RecipeMetadataParser
+from ..constants import GEN_PARAM_KEYS
+
+logger = logging.getLogger(__name__)
+
+class ComfyMetadataParser(RecipeMetadataParser):
+    """Parser for Civitai ComfyUI metadata JSON format"""
+    
+    METADATA_MARKER = r"class_type"
+    
+    def is_metadata_matching(self, user_comment: str) -> bool:
+        """Check if the user comment matches the ComfyUI metadata format"""
+        try:
+            data = json.loads(user_comment)
+            # Check if it contains class_type nodes typical of ComfyUI workflow
+            return isinstance(data, dict) and any(isinstance(v, dict) and 'class_type' in v for v in data.values())
+        except (json.JSONDecodeError, TypeError):
+            return False
+    
+    async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
+        """Parse metadata from Civitai ComfyUI metadata format"""
+        try:
+            data = json.loads(user_comment)
+            loras = []
+            
+            # Find all LoraLoader nodes
+            lora_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and v.get('class_type') == 'LoraLoader'}
+            
+            if not lora_nodes:
+                return {"error": "No LoRA information found in this ComfyUI workflow", "loras": []}
+            
+            # Process each LoraLoader node
+            for node_id, node in lora_nodes.items():
+                if 'inputs' not in node or 'lora_name' not in node['inputs']:
+                    continue
+                    
+                lora_name = node['inputs'].get('lora_name', '')
+                
+                # Parse the URN to extract model ID and version ID
+                # Format: "urn:air:sdxl:lora:civitai:1107767@1253442"
+                lora_id_match = re.search(r'civitai:(\d+)@(\d+)', lora_name)
+                if not lora_id_match:
+                    continue
+                    
+                model_id = lora_id_match.group(1)
+                model_version_id = lora_id_match.group(2)
+                
+                # Get strength from node inputs
+                weight = node['inputs'].get('strength_model', 1.0)
+                
+                # Initialize lora entry with default values
+                lora_entry = {
+                    'id': model_version_id,
+                    'modelId': model_id,
+                    'name': f"Lora {model_id}",  # Default name
+                    'version': '',
+                    'type': 'lora',
+                    'weight': weight,
+                    'existsLocally': False,
+                    'localPath': None,
+                    'file_name': '',
+                    'hash': '',
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
+                    'baseModel': '',
+                    'size': 0,
+                    'downloadUrl': '',
+                    'isDeleted': False
+                }
+                
+                # Get additional info from Civitai if client is available
+                if civitai_client:
+                    try:
+                        civitai_info_tuple = await civitai_client.get_model_version_info(model_version_id)
+                        # Populate lora entry with Civitai info
+                        populated_entry = await self.populate_lora_from_civitai(
+                            lora_entry, 
+                            civitai_info_tuple, 
+                            recipe_scanner
+                        )
+                        if populated_entry is None:
+                            continue  # Skip invalid LoRA types
+                        lora_entry = populated_entry
+                    except Exception as e:
+                        logger.error(f"Error fetching Civitai info for LoRA: {e}")
+                
+                loras.append(lora_entry)
+            
+            # Find checkpoint info
+            checkpoint_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and v.get('class_type') == 'CheckpointLoaderSimple'}
+            checkpoint = None
+            checkpoint_id = None
+            checkpoint_version_id = None
+            
+            if checkpoint_nodes:
+                # Get the first checkpoint node
+                checkpoint_node = next(iter(checkpoint_nodes.values()))
+                if 'inputs' in checkpoint_node and 'ckpt_name' in checkpoint_node['inputs']:
+                    checkpoint_name = checkpoint_node['inputs']['ckpt_name']
+                    # Parse checkpoint URN
+                    checkpoint_match = re.search(r'civitai:(\d+)@(\d+)', checkpoint_name)
+                    if checkpoint_match:
+                        checkpoint_id = checkpoint_match.group(1)
+                        checkpoint_version_id = checkpoint_match.group(2)
+                        checkpoint = {
+                            'id': checkpoint_version_id,
+                            'modelId': checkpoint_id,
+                            'name': f"Checkpoint {checkpoint_id}",
+                            'version': '',
+                            'type': 'checkpoint'
+                        }
+                        
+                        # Get additional checkpoint info from Civitai
+                        if civitai_client:
+                            try:
+                                civitai_info_tuple = await civitai_client.get_model_version_info(checkpoint_version_id)
+                                civitai_info, _ = civitai_info_tuple if isinstance(civitai_info_tuple, tuple) else (civitai_info_tuple, None)
+                                # Populate checkpoint with Civitai info
+                                checkpoint = await self.populate_checkpoint_from_civitai(checkpoint, civitai_info)
+                            except Exception as e:
+                                logger.error(f"Error fetching Civitai info for checkpoint: {e}")
+            
+            # Extract generation parameters
+            gen_params = {}
+            
+            # First try to get from extraMetadata
+            if 'extraMetadata' in data:
+                try:
+                    # extraMetadata is a JSON string that needs to be parsed
+                    extra_metadata = json.loads(data['extraMetadata'])
+                    
+                    # Map fields from extraMetadata to our standard format
+                    mapping = {
+                        'prompt': 'prompt',
+                        'negativePrompt': 'negative_prompt',
+                        'steps': 'steps',
+                        'sampler': 'sampler',
+                        'cfgScale': 'cfg_scale',
+                        'seed': 'seed'
+                    }
+                    
+                    for src_key, dest_key in mapping.items():
+                        if src_key in extra_metadata:
+                            gen_params[dest_key] = extra_metadata[src_key]
+                    
+                    # If size info is available, format as "width x height"
+                    if 'width' in extra_metadata and 'height' in extra_metadata:
+                        gen_params['size'] = f"{extra_metadata['width']}x{extra_metadata['height']}"
+                    
+                except Exception as e:
+                    logger.error(f"Error parsing extraMetadata: {e}")
+            
+            # If extraMetadata doesn't have all the info, try to get from nodes
+            if not gen_params or len(gen_params) < 3:  # At least we want prompt, negative_prompt, and steps
+                # Find positive prompt node
+                positive_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and 
+                                v.get('class_type', '').endswith('CLIPTextEncode') and 
+                                v.get('_meta', {}).get('title') == 'Positive'}
+                
+                if positive_nodes:
+                    positive_node = next(iter(positive_nodes.values()))
+                    if 'inputs' in positive_node and 'text' in positive_node['inputs']:
+                        gen_params['prompt'] = positive_node['inputs']['text']
+                
+                # Find negative prompt node
+                negative_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and 
+                                v.get('class_type', '').endswith('CLIPTextEncode') and 
+                                v.get('_meta', {}).get('title') == 'Negative'}
+                
+                if negative_nodes:
+                    negative_node = next(iter(negative_nodes.values()))
+                    if 'inputs' in negative_node and 'text' in negative_node['inputs']:
+                        gen_params['negative_prompt'] = negative_node['inputs']['text']
+                
+                # Find KSampler node for other parameters
+                ksampler_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and v.get('class_type') == 'KSampler'}
+                
+                if ksampler_nodes:
+                    ksampler_node = next(iter(ksampler_nodes.values()))
+                    if 'inputs' in ksampler_node:
+                        inputs = ksampler_node['inputs']
+                        if 'sampler_name' in inputs:
+                            gen_params['sampler'] = inputs['sampler_name']
+                        if 'steps' in inputs:
+                            gen_params['steps'] = inputs['steps']
+                        if 'cfg' in inputs:
+                            gen_params['cfg_scale'] = inputs['cfg']
+                        if 'seed' in inputs:
+                            gen_params['seed'] = inputs['seed']
+            
+            # Determine base model from loras info
+            base_model = None
+            if loras:
+                # Use the most common base model from loras
+                base_models = [lora['baseModel'] for lora in loras if lora.get('baseModel')]
+                if base_models:
+                    from collections import Counter
+                    base_model_counts = Counter(base_models)
+                    base_model = base_model_counts.most_common(1)[0][0]
+            
+            return {
+                'base_model': base_model,
+                'loras': loras,
+                'checkpoint': checkpoint,
+                'gen_params': gen_params,
+                'from_comfy_metadata': True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error parsing ComfyUI metadata: {e}", exc_info=True)
+            return {"error": str(e), "loras": []}

py/recipes/parsers/meta_format.py

@@ -0,0 +1,174 @@
+"""Parser for meta format (Lora_N Model hash) metadata."""
+
+import re
+import logging
+from typing import Dict, Any
+from ..base import RecipeMetadataParser
+from ..constants import GEN_PARAM_KEYS
+
+logger = logging.getLogger(__name__)
+
+class MetaFormatParser(RecipeMetadataParser):
+    """Parser for images with meta format metadata (Lora_N Model hash format)"""
+    
+    METADATA_MARKER = r'Lora_\d+ Model hash:'
+    
+    def is_metadata_matching(self, user_comment: str) -> bool:
+        """Check if the user comment matches the metadata format"""
+        return re.search(self.METADATA_MARKER, user_comment, re.IGNORECASE | re.DOTALL) is not None
+    
+    async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
+        """Parse metadata from images with meta format metadata"""
+        try:
+            # Extract prompt and negative prompt
+            parts = user_comment.split('Negative prompt:', 1)
+            prompt = parts[0].strip()
+            
+            # Initialize metadata
+            metadata = {"prompt": prompt, "loras": []}
+            
+            # Extract negative prompt and parameters if available
+            if len(parts) > 1:
+                negative_and_params = parts[1]
+                
+                # Extract negative prompt - everything until the first parameter (usually "Steps:")
+                param_start = re.search(r'([A-Za-z]+): ', negative_and_params)
+                if param_start:
+                    neg_prompt = negative_and_params[:param_start.start()].strip()
+                    metadata["negative_prompt"] = neg_prompt
+                    params_section = negative_and_params[param_start.start():]
+                else:
+                    params_section = negative_and_params
+                
+                # Extract key-value parameters (Steps, Sampler, Seed, etc.)
+                param_pattern = r'([A-Za-z_0-9 ]+): ([^,]+)'
+                params = re.findall(param_pattern, params_section)
+                for key, value in params:
+                    clean_key = key.strip().lower().replace(' ', '_')
+                    metadata[clean_key] = value.strip()
+            
+            # Extract LoRA information
+            # Pattern to match lora entries: Lora_0 Model name: ArtVador I.safetensors, Lora_0 Model hash: 08f7133a58, etc.
+            lora_pattern = r'Lora_(\d+) Model name: ([^,]+), Lora_\1 Model hash: ([^,]+), Lora_\1 Strength model: ([^,]+), Lora_\1 Strength clip: ([^,]+)'
+            lora_matches = re.findall(lora_pattern, user_comment)
+            
+            # If the regular pattern doesn't match, try a more flexible approach
+            if not lora_matches:
+                # First find all Lora indices
+                lora_indices = set(re.findall(r'Lora_(\d+)', user_comment))
+                
+                # For each index, extract the information
+                for idx in lora_indices:
+                    lora_info = {}
+                    
+                    # Extract model name
+                    name_match = re.search(f'Lora_{idx} Model name: ([^,]+)', user_comment)
+                    if name_match:
+                        lora_info['name'] = name_match.group(1).strip()
+                    
+                    # Extract model hash
+                    hash_match = re.search(f'Lora_{idx} Model hash: ([^,]+)', user_comment)
+                    if hash_match:
+                        lora_info['hash'] = hash_match.group(1).strip()
+                    
+                    # Extract strength model
+                    strength_model_match = re.search(f'Lora_{idx} Strength model: ([^,]+)', user_comment)
+                    if strength_model_match:
+                        lora_info['strength_model'] = float(strength_model_match.group(1).strip())
+                    
+                    # Extract strength clip
+                    strength_clip_match = re.search(f'Lora_{idx} Strength clip: ([^,]+)', user_comment)
+                    if strength_clip_match:
+                        lora_info['strength_clip'] = float(strength_clip_match.group(1).strip())
+                    
+                    # Only add if we have at least name and hash
+                    if 'name' in lora_info and 'hash' in lora_info:
+                        lora_matches.append((idx, lora_info['name'], lora_info['hash'], 
+                                            str(lora_info.get('strength_model', 1.0)), 
+                                            str(lora_info.get('strength_clip', 1.0))))
+            
+            # Process LoRAs
+            base_model_counts = {}
+            loras = []
+            
+            for match in lora_matches:
+                if len(match) == 5:  # Regular pattern match
+                    idx, name, hash_value, strength_model, strength_clip = match
+                else:  # Flexible approach match
+                    continue  # Should not happen now
+                
+                # Clean up the values
+                name = name.strip()
+                if name.endswith('.safetensors'):
+                    name = name[:-12]  # Remove .safetensors extension
+                    
+                hash_value = hash_value.strip()
+                weight = float(strength_model)  # Use model strength as weight
+                
+                # Initialize lora entry with default values
+                lora_entry = {
+                    'name': name,
+                    'type': 'lora',
+                    'weight': weight,
+                    'existsLocally': False,
+                    'localPath': None,
+                    'file_name': name,
+                    'hash': hash_value,
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
+                    'baseModel': '',
+                    'size': 0,
+                    'downloadUrl': '',
+                    'isDeleted': False
+                }
+                
+                # Get info from Civitai by hash if available
+                if civitai_client and hash_value:
+                    try:
+                        civitai_info = await civitai_client.get_model_by_hash(hash_value)
+                        # Populate lora entry with Civitai info
+                        populated_entry = await self.populate_lora_from_civitai(
+                            lora_entry, 
+                            civitai_info, 
+                            recipe_scanner,
+                            base_model_counts,
+                            hash_value
+                        )
+                        if populated_entry is None:
+                            continue  # Skip invalid LoRA types
+                        lora_entry = populated_entry
+                    except Exception as e:
+                        logger.error(f"Error fetching Civitai info for LoRA hash {hash_value}: {e}")
+                
+                loras.append(lora_entry)
+            
+            # Extract model information
+            model = None
+            if 'model' in metadata:
+                model = metadata['model']
+            
+            # Set base_model to the most common one from civitai_info
+            base_model = None
+            if base_model_counts:
+                base_model = max(base_model_counts.items(), key=lambda x: x[1])[0]
+            
+            # Extract generation parameters for recipe metadata
+            gen_params = {}
+            for key in GEN_PARAM_KEYS:
+                if key in metadata:
+                    gen_params[key] = metadata.get(key, '')
+            
+            # Try to extract size information if available
+            if 'width' in metadata and 'height' in metadata:
+                gen_params['size'] = f"{metadata['width']}x{metadata['height']}"
+            
+            return {
+                'base_model': base_model,
+                'loras': loras,
+                'gen_params': gen_params,
+                'raw_metadata': metadata,
+                'from_meta_format': True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error parsing meta format metadata: {e}", exc_info=True)
+            return {"error": str(e), "loras": []}

py/recipes/parsers/recipe_format.py

@@ -0,0 +1,114 @@
+"""Parser for dedicated recipe metadata format."""
+
+import re
+import json
+import logging
+from typing import Dict, Any
+from ...config import config
+from ..base import RecipeMetadataParser
+from ..constants import GEN_PARAM_KEYS
+
+logger = logging.getLogger(__name__)
+
+class RecipeFormatParser(RecipeMetadataParser):
+    """Parser for images with dedicated recipe metadata format"""
+    
+    # Regular expression pattern for extracting recipe metadata
+    METADATA_MARKER = r'Recipe metadata: (\{.*\})'
+    
+    def is_metadata_matching(self, user_comment: str) -> bool:
+        """Check if the user comment matches the metadata format"""
+        return re.search(self.METADATA_MARKER, user_comment, re.IGNORECASE | re.DOTALL) is not None
+    
+    async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
+        """Parse metadata from images with dedicated recipe metadata format"""
+        try:
+            # Extract recipe metadata from user comment
+            try:
+                # Look for recipe metadata section
+                recipe_match = re.search(self.METADATA_MARKER, user_comment, re.IGNORECASE | re.DOTALL)
+                if not recipe_match:
+                    recipe_metadata = None
+                else:
+                    recipe_json = recipe_match.group(1)
+                    recipe_metadata = json.loads(recipe_json)
+            except Exception as e:
+                logger.error(f"Error extracting recipe metadata: {e}")
+                recipe_metadata = None
+            if not recipe_metadata:
+                return {"error": "No recipe metadata found", "loras": []}
+                
+            # Process the recipe metadata
+            loras = []
+            for lora in recipe_metadata.get('loras', []):
+                # Convert recipe lora format to frontend format
+                lora_entry = {
+                    'id': lora.get('modelVersionId', ''),
+                    'name': lora.get('modelName', ''),
+                    'version': lora.get('modelVersionName', ''),
+                    'type': 'lora',
+                    'weight': lora.get('strength', 1.0),
+                    'file_name': lora.get('file_name', ''),
+                    'hash': lora.get('hash', '')
+                }
+                
+                # Check if this LoRA exists locally by SHA256 hash
+                if lora.get('hash') and recipe_scanner:
+                    lora_scanner = recipe_scanner._lora_scanner
+                    exists_locally = lora_scanner.has_lora_hash(lora['hash'])
+                    if exists_locally:
+                        lora_cache = await lora_scanner.get_cached_data()
+                        lora_item = next((item for item in lora_cache.raw_data if item['sha256'].lower() == lora['hash'].lower()), None)
+                        if lora_item:
+                            lora_entry['existsLocally'] = True
+                            lora_entry['localPath'] = lora_item['file_path']
+                            lora_entry['file_name'] = lora_item['file_name']
+                            lora_entry['size'] = lora_item['size']
+                            lora_entry['thumbnailUrl'] = config.get_preview_static_url(lora_item['preview_url'])
+                            
+                    else:
+                        lora_entry['existsLocally'] = False
+                        lora_entry['localPath'] = None
+                        
+                        # Try to get additional info from Civitai if we have a model version ID
+                        if lora.get('modelVersionId') and civitai_client:
+                            try:
+                                civitai_info_tuple = await civitai_client.get_model_version_info(lora['modelVersionId'])
+                                # Populate lora entry with Civitai info
+                                populated_entry = await self.populate_lora_from_civitai(
+                                    lora_entry, 
+                                    civitai_info_tuple, 
+                                    recipe_scanner,
+                                    None,  # No need to track base model counts
+                                    lora['hash']
+                                )
+                                if populated_entry is None:
+                                    continue  # Skip invalid LoRA types
+                                lora_entry = populated_entry
+                            except Exception as e:
+                                logger.error(f"Error fetching Civitai info for LoRA: {e}")
+                                lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
+                
+                loras.append(lora_entry)
+
+            logger.info(f"Found {len(loras)} loras in recipe metadata")
+            
+            # Filter gen_params to only include recognized keys
+            filtered_gen_params = {}
+            if 'gen_params' in recipe_metadata:
+                for key, value in recipe_metadata['gen_params'].items():
+                    if key in GEN_PARAM_KEYS:
+                        filtered_gen_params[key] = value
+            
+            return {
+                'base_model': recipe_metadata.get('base_model', ''),
+                'loras': loras,
+                'gen_params': filtered_gen_params,
+                'tags': recipe_metadata.get('tags', []),
+                'title': recipe_metadata.get('title', ''),
+                'from_recipe_metadata': True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error parsing recipe format metadata: {e}", exc_info=True)
+            return {"error": str(e), "loras": []}

py/routes/api_routes.py

@@ -43,6 +43,7 @@ class ApiRoutes:
         app.on_startup.append(lambda _: routes.initialize_services())
         
         app.router.add_post('/api/delete_model', routes.delete_model)
+        app.router.add_post('/api/loras/exclude', routes.exclude_model)  # Add new exclude endpoint
         app.router.add_post('/api/fetch-civitai', routes.fetch_civitai)
         app.router.add_post('/api/replace_preview', routes.replace_preview)
         app.router.add_get('/api/loras', routes.get_loras)
@@ -69,6 +70,13 @@ class ApiRoutes:
         # Add the new trigger words route
         app.router.add_post('/loramanager/get_trigger_words', routes.get_trigger_words)
 
+        # Add new endpoint for letter counts
+        app.router.add_get('/api/loras/letter-counts', routes.get_letter_counts)
+        
+        # Add new endpoints for copying lora data
+        app.router.add_get('/api/loras/get-notes', routes.get_lora_notes)
+        app.router.add_get('/api/loras/get-trigger-words', routes.get_lora_trigger_words)
+
         # Add update check routes
         UpdateRoutes.setup_routes(app)
 
@@ -78,6 +86,12 @@ class ApiRoutes:
             self.scanner = await ServiceRegistry.get_lora_scanner()
         return await ModelRouteUtils.handle_delete_model(request, self.scanner)
 
+    async def exclude_model(self, request: web.Request) -> web.Response:
+        """Handle model exclusion request"""
+        if self.scanner is None:
+            self.scanner = await ServiceRegistry.get_lora_scanner()
+        return await ModelRouteUtils.handle_exclude_model(request, self.scanner)
+
     async def fetch_civitai(self, request: web.Request) -> web.Response:
         """Handle CivitAI metadata fetch request"""
         if self.scanner is None:
@@ -126,6 +140,9 @@ class ApiRoutes:
             tags = request.query.get('tags', None)
             favorites_only = request.query.get('favorites_only', 'false').lower() == 'true'  # New parameter
             
+            # New parameter for alphabet filtering
+            first_letter = request.query.get('first_letter', None)
+            
             # New parameters for recipe filtering
             lora_hash = request.query.get('lora_hash', None)
             lora_hashes = request.query.get('lora_hashes', None)
@@ -156,7 +173,8 @@ class ApiRoutes:
                 tags=filters.get('tags', None),
                 search_options=search_options,
                 hash_filters=hash_filters,
-                favorites_only=favorites_only  # Pass favorites_only parameter
+                favorites_only=favorites_only,  # Pass favorites_only parameter
+                first_letter=first_letter  # Pass the new first_letter parameter
             )
 
             # Get all available folders from cache
@@ -372,10 +390,10 @@ class ApiRoutes:
             versions = response.get('modelVersions', [])
             model_type = response.get('type', '')
             
-            # Check model type - should be LORA
-            if model_type.lower() != 'lora':
+            # Check model type - should be LORA or LoCon
+            if model_type.lower() not in ['lora', 'locon']:
                 return web.json_response({
-                    'error': f"Model type mismatch. Expected LORA, got {model_type}"
+                    'error': f"Model type mismatch. Expected LORA or LoCon, got {model_type}"
                 }, status=400)
             
             # Check local availability for each version
@@ -781,11 +799,13 @@ class ApiRoutes:
             # Check if we already have the description stored in metadata
             description = None
             tags = []
+            creator = {}
             if file_path:
                 metadata_path = os.path.splitext(file_path)[0] + '.metadata.json'
                 metadata = await ModelRouteUtils.load_local_metadata(metadata_path)
                 description = metadata.get('modelDescription')
                 tags = metadata.get('tags', [])
+                creator = metadata.get('creator', {})
             
             # If description is not in metadata, fetch from CivitAI
             if not description:
@@ -795,6 +815,7 @@ class ApiRoutes:
                 if (model_metadata):
                     description = model_metadata.get('description')
                     tags = model_metadata.get('tags', [])
+                    creator = model_metadata.get('creator', {})
                 
                     # Save the metadata to file if we have a file path and got metadata
                     if file_path:
@@ -804,6 +825,7 @@ class ApiRoutes:
                             
                             metadata['modelDescription'] = description
                             metadata['tags'] = tags
+                            metadata['creator'] = creator
                             
                             with open(metadata_path, 'w', encoding='utf-8') as f:
                                 json.dump(metadata, f, indent=2, ensure_ascii=False)
@@ -814,7 +836,8 @@ class ApiRoutes:
             return web.json_response({
                 'success': True,
                 'description': description or "<p>No model description available.</p>",
-                'tags': tags
+                'tags': tags,
+                'creator': creator
             })
             
         except Exception as e:
@@ -1045,3 +1068,101 @@ class ApiRoutes:
                 "success": False,
                 "error": str(e)
             }, status=500)
+
+    async def get_letter_counts(self, request: web.Request) -> web.Response:
+        """Get count of loras for each letter of the alphabet"""
+        try:
+            if self.scanner is None:
+                self.scanner = await ServiceRegistry.get_lora_scanner()
+                
+            # Get letter counts
+            letter_counts = await self.scanner.get_letter_counts()
+            
+            return web.json_response({
+                'success': True,
+                'letter_counts': letter_counts
+            })
+        except Exception as e:
+            logger.error(f"Error getting letter counts: {e}")
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)
+
+    async def get_lora_notes(self, request: web.Request) -> web.Response:
+        """Get notes for a specific LoRA file"""
+        try:
+            if self.scanner is None:
+                self.scanner = await ServiceRegistry.get_lora_scanner()
+                
+            # Get lora file name from query parameters
+            lora_name = request.query.get('name')
+            if not lora_name:
+                return web.Response(text='Lora file name is required', status=400)
+
+            # Get cache data
+            cache = await self.scanner.get_cached_data()
+            
+            # Search for the lora in cache data
+            for lora in cache.raw_data:
+                file_name = lora['file_name']
+                if file_name == lora_name:
+                    notes = lora.get('notes', '')
+                    
+                    return web.json_response({
+                        'success': True,
+                        'notes': notes
+                    })
+
+            # If lora not found
+            return web.json_response({
+                'success': False,
+                'error': 'LoRA not found in cache'
+            }, status=404)
+
+        except Exception as e:
+            logger.error(f"Error getting lora notes: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)
+
+    async def get_lora_trigger_words(self, request: web.Request) -> web.Response:
+        """Get trigger words for a specific LoRA file"""
+        try:
+            if self.scanner is None:
+                self.scanner = await ServiceRegistry.get_lora_scanner()
+                
+            # Get lora file name from query parameters
+            lora_name = request.query.get('name')
+            if not lora_name:
+                return web.Response(text='Lora file name is required', status=400)
+
+            # Get cache data
+            cache = await self.scanner.get_cached_data()
+            
+            # Search for the lora in cache data
+            for lora in cache.raw_data:
+                file_name = lora['file_name']
+                if file_name == lora_name:
+                    # Get trigger words from civitai data
+                    civitai_data = lora.get('civitai', {})
+                    trigger_words = civitai_data.get('trainedWords', [])
+                    
+                    return web.json_response({
+                        'success': True,
+                        'trigger_words': trigger_words
+                    })
+
+            # If lora not found
+            return web.json_response({
+                'success': False,
+                'error': 'LoRA not found in cache'
+            }, status=404)
+
+        except Exception as e:
+            logger.error(f"Error getting lora trigger words: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)

py/routes/checkpoints_routes.py

@@ -49,6 +49,7 @@ class CheckpointsRoutes:
         
         # Add new routes for model management similar to LoRA routes
         app.router.add_post('/api/checkpoints/delete', self.delete_model)
+        app.router.add_post('/api/checkpoints/exclude', self.exclude_model)  # Add new exclude endpoint
         app.router.add_post('/api/checkpoints/fetch-civitai', self.fetch_civitai)
         app.router.add_post('/api/checkpoints/replace-preview', self.replace_preview)
         app.router.add_post('/api/checkpoints/download', self.download_checkpoint)
@@ -429,7 +430,7 @@ class CheckpointsRoutes:
         """Get detailed information for a specific checkpoint by name"""
         try:
             name = request.match_info.get('name', '')
-            checkpoint_info = await self.scanner.get_checkpoint_info_by_name(name)
+            checkpoint_info = await self.scanner.get_model_info_by_name(name)
             
             if checkpoint_info:
                 return web.json_response(checkpoint_info)
@@ -499,6 +500,10 @@ class CheckpointsRoutes:
     async def delete_model(self, request: web.Request) -> web.Response:
         """Handle checkpoint model deletion request"""
         return await ModelRouteUtils.handle_delete_model(request, self.scanner)
+
+    async def exclude_model(self, request: web.Request) -> web.Response:
+        """Handle checkpoint model exclusion request"""
+        return await ModelRouteUtils.handle_exclude_model(request, self.scanner)
     
     async def fetch_civitai(self, request: web.Request) -> web.Response:
         """Handle CivitAI metadata fetch request for checkpoints"""
@@ -653,7 +658,7 @@ class CheckpointsRoutes:
             model_type = response.get('type', '')
             
             # Check model type - should be Checkpoint
-            if model_type.lower() != 'checkpoint':
+            if (model_type.lower() != 'checkpoint'):
                 return web.json_response({
                     'error': f"Model type mismatch. Expected Checkpoint, got {model_type}"
                 }, status=400)

py/routes/misc_routes.py

@@ -3,8 +3,6 @@ import os
 import asyncio
 import json
 import time
-import tkinter as tk
-from tkinter import filedialog
 import aiohttp
 from aiohttp import web
 from ..services.settings_manager import settings
@@ -12,6 +10,8 @@ from ..utils.usage_stats import UsageStats
 from ..services.service_registry import ServiceRegistry
 from ..utils.exif_utils import ExifUtils
 from ..utils.constants import EXAMPLE_IMAGE_WIDTH, SUPPORTED_MEDIA_EXTENSIONS
+from ..services.civitai_client import CivitaiClient
+from ..utils.routes_common import ModelRouteUtils
 
 logger = logging.getLogger(__name__)
 
@@ -27,7 +27,8 @@ download_progress = {
     'last_error': None,
     'start_time': None,
     'end_time': None,
-    'processed_models': set()  # Track models that have been processed
+    'processed_models': set(),  # Track models that have been processed
+    'refreshed_models': set()  # Track models that had metadata refreshed
 }
 
 class MiscRoutes:
@@ -151,6 +152,7 @@ class MiscRoutes:
             # Create a copy for JSON serialization
             response_progress = download_progress.copy()
             response_progress['processed_models'] = list(download_progress['processed_models'])
+            response_progress['refreshed_models'] = list(download_progress['refreshed_models'])
             
             return web.json_response({
                 'success': False,
@@ -164,7 +166,7 @@ class MiscRoutes:
             output_dir = data.get('output_dir')
             optimize = data.get('optimize', True)
             model_types = data.get('model_types', ['lora', 'checkpoint'])
-            delay = float(data.get('delay', 0.2))
+            delay = float(data.get('delay', 0.1)) # Default to 0.1 seconds
             
             if not output_dir:
                 return web.json_response({
@@ -213,6 +215,7 @@ class MiscRoutes:
             # Create a copy for JSON serialization
             response_progress = download_progress.copy()
             response_progress['processed_models'] = list(download_progress['processed_models'])
+            response_progress['refreshed_models'] = list(download_progress['refreshed_models'])
             
             return web.json_response({
                 'success': True,
@@ -235,6 +238,7 @@ class MiscRoutes:
         # Create a copy of the progress dict with the set converted to a list for JSON serialization
         response_progress = download_progress.copy()
         response_progress['processed_models'] = list(download_progress['processed_models'])
+        response_progress['refreshed_models'] = list(download_progress['refreshed_models'])
         
         return web.json_response({
             'success': True,
@@ -284,6 +288,259 @@ class MiscRoutes:
                 'error': f"Download is in '{download_progress['status']}' state, cannot resume"
             }, status=400)
 
+    @staticmethod
+    async def _refresh_model_metadata(model_hash, model_name, scanner_type, scanner):
+        """Refresh model metadata from CivitAI
+        
+        Args:
+            model_hash: SHA256 hash of the model
+            model_name: Name of the model (for logging)
+            scanner_type: Type of scanner ('lora' or 'checkpoint')
+            scanner: Scanner instance for this model type
+            
+        Returns:
+            bool: True if metadata was successfully refreshed, False otherwise
+        """
+        global download_progress
+        
+        try:
+            # Find the model in the scanner cache
+            cache = await scanner.get_cached_data()
+            model_data = None
+            
+            for item in cache.raw_data:
+                if item.get('sha256') == model_hash:
+                    model_data = item
+                    break
+            
+            if not model_data:
+                logger.warning(f"Model {model_name} with hash {model_hash} not found in cache")
+                return False
+            
+            file_path = model_data.get('file_path')
+            if not file_path:
+                logger.warning(f"Model {model_name} has no file path")
+                return False
+            
+            # Track that we're refreshing this model
+            download_progress['refreshed_models'].add(model_hash)
+            
+            # Use ModelRouteUtils to refresh the metadata
+            async def update_cache_func(old_path, new_path, metadata):
+                return await scanner.update_single_model_cache(old_path, new_path, metadata)
+            
+            success = await ModelRouteUtils.fetch_and_update_model(
+                model_hash, 
+                file_path, 
+                model_data,
+                update_cache_func
+            )
+            
+            if success:
+                logger.info(f"Successfully refreshed metadata for {model_name}")
+                return True
+            else:
+                logger.warning(f"Failed to refresh metadata for {model_name}")
+                return False
+                
+        except Exception as e:
+            error_msg = f"Error refreshing metadata for {model_name}: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            download_progress['errors'].append(error_msg)
+            download_progress['last_error'] = error_msg
+            return False
+    
+    @staticmethod
+    async def _process_model_images(model_hash, model_name, model_images, model_dir, optimize, independent_session, delay):
+        """Process and download images for a single model
+        
+        Args:
+            model_hash: SHA256 hash of the model
+            model_name: Name of the model
+            model_images: List of image objects from CivitAI
+            model_dir: Directory to save images to
+            optimize: Whether to optimize images
+            independent_session: aiohttp session for downloads
+            delay: Delay between downloads
+            
+        Returns:
+            bool: True if all images were processed successfully, False otherwise
+        """
+        global download_progress
+        
+        model_success = True
+        
+        for i, image in enumerate(model_images, 1):
+            image_url = image.get('url')
+            if not image_url:
+                continue
+            
+            # Get image filename from URL
+            image_filename = os.path.basename(image_url.split('?')[0])
+            image_ext = os.path.splitext(image_filename)[1].lower()
+            
+            # Handle both images and videos
+            is_image = image_ext in SUPPORTED_MEDIA_EXTENSIONS['images']
+            is_video = image_ext in SUPPORTED_MEDIA_EXTENSIONS['videos']
+            
+            if not (is_image or is_video):
+                logger.debug(f"Skipping unsupported file type: {image_filename}")
+                continue
+            
+            save_filename = f"image_{i}{image_ext}"
+            
+            # Check if already downloaded
+            save_path = os.path.join(model_dir, save_filename)
+            if os.path.exists(save_path):
+                logger.debug(f"File already exists: {save_path}")
+                continue
+            
+            # Download the file
+            try:
+                logger.debug(f"Downloading {save_filename} for {model_name}")
+                
+                # Direct download using the independent session
+                async with independent_session.get(image_url, timeout=60) as response:
+                    if response.status == 200:
+                        if is_image and optimize:
+                            # For images, optimize if requested
+                            image_data = await response.read()
+                            optimized_data, ext = ExifUtils.optimize_image(
+                                image_data, 
+                                target_width=EXAMPLE_IMAGE_WIDTH, 
+                                format='webp', 
+                                quality=85, 
+                                preserve_metadata=False
+                            )
+                            
+                            # Update save filename if format changed
+                            if ext == '.webp':
+                                save_filename = os.path.splitext(save_filename)[0] + '.webp'
+                                save_path = os.path.join(model_dir, save_filename)
+                            
+                            # Save the optimized image
+                            with open(save_path, 'wb') as f:
+                                f.write(optimized_data)
+                        else:
+                            # For videos or unoptimized images, save directly
+                            with open(save_path, 'wb') as f:
+                                async for chunk in response.content.iter_chunked(8192):
+                                    if chunk:
+                                        f.write(chunk)
+                    elif response.status == 404:
+                        error_msg = f"Failed to download file: {image_url}, status code: 404 - Model metadata might be stale"
+                        logger.warning(error_msg)
+                        download_progress['errors'].append(error_msg)
+                        download_progress['last_error'] = error_msg
+                        model_success = False  # Mark model as failed due to 404
+                        # Return early to trigger metadata refresh attempt
+                        return False, True  # (success, is_stale_metadata)
+                    else:
+                        error_msg = f"Failed to download file: {image_url}, status code: {response.status}"
+                        logger.warning(error_msg)
+                        download_progress['errors'].append(error_msg)
+                        download_progress['last_error'] = error_msg
+                        model_success = False  # Mark model as failed
+                
+                # Add a delay between downloads for remote files only
+                await asyncio.sleep(delay)
+            except Exception as e:
+                error_msg = f"Error downloading file {image_url}: {str(e)}"
+                logger.error(error_msg)
+                download_progress['errors'].append(error_msg)
+                download_progress['last_error'] = error_msg
+                model_success = False  # Mark model as failed
+        
+        return model_success, False  # (success, is_stale_metadata)
+    
+    @staticmethod
+    async def _process_local_example_images(model_file_path, model_file_name, model_name, model_dir, optimize):
+        """Process local example images for a model
+        
+        Args:
+            model_file_path: Path to the model file
+            model_file_name: Filename of the model
+            model_name: Name of the model
+            model_dir: Directory to save processed images to
+            optimize: Whether to optimize images
+            
+        Returns:
+            bool: True if local images were processed successfully, False otherwise
+        """
+        global download_progress
+        
+        try:
+            model_dir_path = os.path.dirname(model_file_path)
+            local_images = []
+            
+            # Look for files with pattern: filename.example.*.ext
+            if model_file_name:
+                example_prefix = f"{model_file_name}.example."
+                
+                if os.path.exists(model_dir_path):
+                    for file in os.listdir(model_dir_path):
+                        file_lower = file.lower()
+                        if file_lower.startswith(example_prefix.lower()):
+                            file_ext = os.path.splitext(file_lower)[1]
+                            is_supported = (file_ext in SUPPORTED_MEDIA_EXTENSIONS['images'] or 
+                                           file_ext in SUPPORTED_MEDIA_EXTENSIONS['videos'])
+                            
+                            if is_supported:
+                                local_images.append(os.path.join(model_dir_path, file))
+            
+            # Process local images if found
+            if local_images:
+                logger.info(f"Found {len(local_images)} local example images for {model_name}")
+                
+                for i, local_image_path in enumerate(local_images, 1):
+                    local_ext = os.path.splitext(local_image_path)[1].lower()
+                    save_filename = f"image_{i}{local_ext}"
+                    save_path = os.path.join(model_dir, save_filename)
+                    
+                    # Skip if already exists in output directory
+                    if os.path.exists(save_path):
+                        logger.debug(f"File already exists in output: {save_path}")
+                        continue
+                    
+                    # Handle image processing based on file type and optimize setting
+                    is_image = local_ext in SUPPORTED_MEDIA_EXTENSIONS['images']
+                    
+                    if is_image and optimize:
+                        # Optimize the image
+                        with open(local_image_path, 'rb') as img_file:
+                            image_data = img_file.read()
+                        
+                        optimized_data, ext = ExifUtils.optimize_image(
+                            image_data, 
+                            target_width=EXAMPLE_IMAGE_WIDTH, 
+                            format='webp', 
+                            quality=85, 
+                            preserve_metadata=False
+                        )
+                        
+                        # Update save filename if format changed
+                        if ext == '.webp':
+                            save_filename = os.path.splitext(save_filename)[0] + '.webp'
+                            save_path = os.path.join(model_dir, save_filename)
+                        
+                        # Save the optimized image
+                        with open(save_path, 'wb') as f:
+                            f.write(optimized_data)
+                    else:
+                        # For videos or unoptimized images, copy directly
+                        with open(local_image_path, 'rb') as src_file:
+                            with open(save_path, 'wb') as dst_file:
+                                dst_file.write(src_file.read())
+                
+                return True
+            return False
+        except Exception as e:
+            error_msg = f"Error processing local examples for {model_name}: {str(e)}"
+            logger.error(error_msg)
+            download_progress['errors'].append(error_msg)
+            download_progress['last_error'] = error_msg
+            return False
+
     @staticmethod
     async def _download_all_example_images(output_dir, optimize, model_types, delay):
         """Download example images for all models
@@ -332,14 +589,14 @@ class MiscRoutes:
                     for model in cache.raw_data:
                         # Only process models with images and a valid sha256
                         if model.get('civitai') and model.get('civitai', {}).get('images') and model.get('sha256'):
-                            all_models.append((scanner_type, model))
+                            all_models.append((scanner_type, model, scanner))
             
             # Update total count
             download_progress['total'] = len(all_models)
             logger.info(f"Found {download_progress['total']} models with example images")
             
             # Process each model
-            for scanner_type, model in all_models:
+            for scanner_type, model, scanner in all_models:
                 # Check if download is paused
                 while download_progress['status'] == 'paused':
                     await asyncio.sleep(1)
@@ -349,14 +606,13 @@ class MiscRoutes:
                     logger.info(f"Download stopped: {download_progress['status']}")
                     break
                 
-                model_success = True  # Track if all images for this model download successfully
+                model_hash = model.get('sha256', '').lower()
+                model_name = model.get('model_name', 'Unknown')
+                model_file_path = model.get('file_path', '')
+                model_file_name = model.get('file_name', '')
                 
                 try:
                     # Update current model info
-                    model_hash = model.get('sha256', '').lower()
-                    model_name = model.get('model_name', 'Unknown')
-                    model_file_path = model.get('file_path', '')
-                    model_file_name = model.get('file_name', '')
                     download_progress['current_model'] = f"{model_name} ({model_hash[:8]})"
                     
                     # Skip if already processed
@@ -381,156 +637,69 @@ class MiscRoutes:
                     # First check if we have local example images for this model
                     local_images_processed = False
                     if model_file_path:
-                        try:
-                            model_dir_path = os.path.dirname(model_file_path)
-                            local_images = []
-                            
-                            # Look for files with pattern: filename.example.*.ext
-                            if model_file_name:
-                                example_prefix = f"{model_file_name}.example."
-                                
-                                if os.path.exists(model_dir_path):
-                                    for file in os.listdir(model_dir_path):
-                                        file_lower = file.lower()
-                                        if file_lower.startswith(example_prefix.lower()):
-                                            file_ext = os.path.splitext(file_lower)[1]
-                                            is_supported = (file_ext in SUPPORTED_MEDIA_EXTENSIONS['images'] or 
-                                                           file_ext in SUPPORTED_MEDIA_EXTENSIONS['videos'])
-                                            
-                                            if is_supported:
-                                                local_images.append(os.path.join(model_dir_path, file))
-                            
-                            # Process local images if found
-                            if local_images:
-                                logger.info(f"Found {len(local_images)} local example images for {model_name}")
-                                
-                                for i, local_image_path in enumerate(local_images, 1):
-                                    local_ext = os.path.splitext(local_image_path)[1].lower()
-                                    save_filename = f"image_{i}{local_ext}"
-                                    save_path = os.path.join(model_dir, save_filename)
-                                    
-                                    # Skip if already exists in output directory
-                                    if os.path.exists(save_path):
-                                        logger.debug(f"File already exists in output: {save_path}")
-                                        continue
-                                    
-                                    # Handle image processing based on file type and optimize setting
-                                    is_image = local_ext in SUPPORTED_MEDIA_EXTENSIONS['images']
-                                    
-                                    if is_image and optimize:
-                                        # Optimize the image
-                                        with open(local_image_path, 'rb') as img_file:
-                                            image_data = img_file.read()
-                                        
-                                        optimized_data, ext = ExifUtils.optimize_image(
-                                            image_data, 
-                                            target_width=EXAMPLE_IMAGE_WIDTH, 
-                                            format='webp', 
-                                            quality=85, 
-                                            preserve_metadata=False
-                                        )
-                                        
-                                        # Update save filename if format changed
-                                        if ext == '.webp':
-                                            save_filename = os.path.splitext(save_filename)[0] + '.webp'
-                                            save_path = os.path.join(model_dir, save_filename)
-                                        
-                                        # Save the optimized image
-                                        with open(save_path, 'wb') as f:
-                                            f.write(optimized_data)
-                                    else:
-                                        # For videos or unoptimized images, copy directly
-                                        with open(local_image_path, 'rb') as src_file:
-                                            with open(save_path, 'wb') as dst_file:
-                                                dst_file.write(src_file.read())
-                                
-                                # Mark as successfully processed if all local images were processed
-                                download_progress['processed_models'].add(model_hash)
-                                local_images_processed = True
-                                logger.info(f"Successfully processed local examples for {model_name}")
+                        local_images_processed = await MiscRoutes._process_local_example_images(
+                            model_file_path, 
+                            model_file_name, 
+                            model_name, 
+                            model_dir, 
+                            optimize
+                        )
                         
-                        except Exception as e:
-                            error_msg = f"Error processing local examples for {model_name}: {str(e)}"
-                            logger.error(error_msg)
-                            download_progress['errors'].append(error_msg)
-                            download_progress['last_error'] = error_msg
-                            # Continue to remote download if local processing fails
+                        if local_images_processed:
+                            # Mark as successfully processed if all local images were processed
+                            download_progress['processed_models'].add(model_hash)
+                            logger.info(f"Successfully processed local examples for {model_name}")
                     
                     # If we didn't process local images, download from remote
                     if not local_images_processed:
-                        # Download example images
-                        for i, image in enumerate(images, 1):
-                            image_url = image.get('url')
-                            if not image_url:
-                                continue
+                        # Try to download images
+                        model_success, is_stale_metadata = await MiscRoutes._process_model_images(
+                            model_hash, 
+                            model_name, 
+                            images, 
+                            model_dir, 
+                            optimize, 
+                            independent_session, 
+                            delay
+                        )
+                        
+                        # If metadata is stale (404 error), try to refresh it and download again
+                        if is_stale_metadata and model_hash not in download_progress['refreshed_models']:
+                            logger.info(f"Metadata seems stale for {model_name}, attempting to refresh...")
                             
-                            # Get image filename from URL
-                            image_filename = os.path.basename(image_url.split('?')[0])
-                            image_ext = os.path.splitext(image_filename)[1].lower()
+                            # Refresh metadata from CivitAI
+                            refresh_success = await MiscRoutes._refresh_model_metadata(
+                                model_hash, 
+                                model_name, 
+                                scanner_type, 
+                                scanner
+                            )
                             
-                            # Handle both images and videos
-                            is_image = image_ext in SUPPORTED_MEDIA_EXTENSIONS['images']
-                            is_video = image_ext in SUPPORTED_MEDIA_EXTENSIONS['videos']
-                            
-                            if not (is_image or is_video):
-                                logger.debug(f"Skipping unsupported file type: {image_filename}")
-                                continue
-                            
-                            save_filename = f"image_{i}{image_ext}"
-                            
-                            # Check if already downloaded
-                            save_path = os.path.join(model_dir, save_filename)
-                            if os.path.exists(save_path):
-                                logger.debug(f"File already exists: {save_path}")
-                                continue
-                            
-                            # Download the file
-                            try:
-                                logger.debug(f"Downloading {save_filename} for {model_name}")
+                            if refresh_success:
+                                # Get updated model data
+                                updated_cache = await scanner.get_cached_data()
+                                updated_model = None
                                 
-                                # Direct download using the independent session
-                                async with independent_session.get(image_url, timeout=60) as response:
-                                    if response.status == 200:
-                                        if is_image and optimize:
-                                            # For images, optimize if requested
-                                            image_data = await response.read()
-                                            optimized_data, ext = ExifUtils.optimize_image(
-                                                image_data, 
-                                                target_width=EXAMPLE_IMAGE_WIDTH, 
-                                                format='webp', 
-                                                quality=85, 
-                                                preserve_metadata=False
-                                            )
-                                            
-                                            # Update save filename if format changed
-                                            if ext == '.webp':
-                                                save_filename = os.path.splitext(save_filename)[0] + '.webp'
-                                                save_path = os.path.join(model_dir, save_filename)
-                                            
-                                            # Save the optimized image
-                                            with open(save_path, 'wb') as f:
-                                                f.write(optimized_data)
-                                        else:
-                                            # For videos or unoptimized images, save directly
-                                            with open(save_path, 'wb') as f:
-                                                async for chunk in response.content.iter_chunked(8192):
-                                                    if chunk:
-                                                        f.write(chunk)
-                                    else:
-                                        error_msg = f"Failed to download file: {image_url}, status code: {response.status}"
-                                        logger.warning(error_msg)
-                                        download_progress['errors'].append(error_msg)
-                                        download_progress['last_error'] = error_msg
-                                        model_success = False  # Mark model as failed
+                                for item in updated_cache.raw_data:
+                                    if item.get('sha256') == model_hash:
+                                        updated_model = item
+                                        break
                                 
-                                # Add a delay between downloads for remote files only
-                                await asyncio.sleep(delay)
-                            except Exception as e:
-                                error_msg = f"Error downloading file {image_url}: {str(e)}"
-                                logger.error(error_msg)
-                                download_progress['errors'].append(error_msg)
-                                download_progress['last_error'] = error_msg
-                                model_success = False  # Mark model as failed
+                                if updated_model and updated_model.get('civitai', {}).get('images'):
+                                    # Try downloading with updated metadata
+                                    logger.info(f"Retrying download with refreshed metadata for {model_name}")
+                                    updated_images = updated_model.get('civitai', {}).get('images', [])
+                                    
+                                    # Retry download with new images
+                                    model_success, _ = await MiscRoutes._process_model_images(
+                                        model_hash, 
+                                        model_name, 
+                                        updated_images, 
+                                        model_dir, 
+                                        optimize, 
+                                        independent_session, 
+                                        delay
+                                    )
                         
                         # Only mark model as processed if all images downloaded successfully
                         if model_success:
@@ -544,6 +713,7 @@ class MiscRoutes:
                         with open(progress_file, 'w', encoding='utf-8') as f:
                             json.dump({
                                 'processed_models': list(download_progress['processed_models']),
+                                'refreshed_models': list(download_progress['refreshed_models']),
                                 'completed': download_progress['completed'],
                                 'total': download_progress['total'],
                                 'last_update': time.time()
@@ -584,6 +754,7 @@ class MiscRoutes:
                 with open(progress_file, 'w', encoding='utf-8') as f:
                     json.dump({
                         'processed_models': list(download_progress['processed_models']),
+                        'refreshed_models': list(download_progress['refreshed_models']),
                         'completed': download_progress['completed'],
                         'total': download_progress['total'],
                         'last_update': time.time(),

py/routes/recipe_routes.py

@@ -1,5 +1,6 @@
 import os
 import time
+import base64
 import numpy as np
 from PIL import Image
 import torch
@@ -12,7 +13,7 @@ import json
 import asyncio
 import sys
 from ..utils.exif_utils import ExifUtils
-from ..utils.recipe_parsers import RecipeParserFactory
+from ..recipes import RecipeParserFactory
 from ..utils.constants import CARD_PREVIEW_WIDTH
 
 from ..config import config
@@ -56,6 +57,7 @@ class RecipeRoutes:
         app.router.add_get('/api/recipes', routes.get_recipes)
         app.router.add_get('/api/recipe/{recipe_id}', routes.get_recipe_detail)
         app.router.add_post('/api/recipes/analyze-image', routes.analyze_recipe_image)
+        app.router.add_post('/api/recipes/analyze-local-image', routes.analyze_local_image)
         app.router.add_post('/api/recipes/save', routes.save_recipe)
         app.router.add_delete('/api/recipe/{recipe_id}', routes.delete_recipe)
         
@@ -70,12 +72,18 @@ class RecipeRoutes:
         # Add new endpoint for getting recipe syntax
         app.router.add_get('/api/recipe/{recipe_id}/syntax', routes.get_recipe_syntax)
         
-        # Add new endpoint for updating recipe metadata (name and tags)
+        # Add new endpoint for updating recipe metadata (name, tags and source_path)
         app.router.add_put('/api/recipe/{recipe_id}/update', routes.update_recipe)
         
         # Add new endpoint for reconnecting deleted LoRAs
         app.router.add_post('/api/recipe/lora/reconnect', routes.reconnect_lora)
         
+        # Add new endpoint for finding duplicate recipes
+        app.router.add_get('/api/recipes/find-duplicates', routes.find_duplicates)
+        
+        # Add new endpoint for bulk deletion of recipes
+        app.router.add_post('/api/recipes/bulk-delete', routes.bulk_delete)
+        
         # Start cache initialization
         app.on_startup.append(routes._init_cache)
         
@@ -300,7 +308,6 @@ class RecipeRoutes:
                 
                 # For URL mode, include the image data as base64
                 if is_url_mode and temp_path:
-                    import base64
                     with open(temp_path, "rb") as image_file:
                         result["image_base64"] = base64.b64encode(image_file.read()).decode('utf-8')
                     
@@ -317,7 +324,6 @@ class RecipeRoutes:
                 
                 # For URL mode, include the image data as base64
                 if is_url_mode and temp_path:
-                    import base64
                     with open(temp_path, "rb") as image_file:
                         result["image_base64"] = base64.b64encode(image_file.read()).decode('utf-8')
                     
@@ -332,7 +338,6 @@ class RecipeRoutes:
             
             # For URL mode, include the image data as base64
             if is_url_mode and temp_path:
-                import base64
                 with open(temp_path, "rb") as image_file:
                     result["image_base64"] = base64.b64encode(image_file.read()).decode('utf-8')
             
@@ -340,6 +345,21 @@ class RecipeRoutes:
             if "error" in result and not result.get("loras"):
                 return web.json_response(result, status=200)
             
+            # Calculate fingerprint from parsed loras
+            from ..utils.utils import calculate_recipe_fingerprint
+            fingerprint = calculate_recipe_fingerprint(result.get("loras", []))
+            
+            # Add fingerprint to result
+            result["fingerprint"] = fingerprint
+            
+            # Find matching recipes with the same fingerprint
+            matching_recipes = []
+            if fingerprint:
+                matching_recipes = await self.recipe_scanner.find_recipes_by_fingerprint(fingerprint)
+                
+            # Add matching recipes to result
+            result["matching_recipes"] = matching_recipes
+            
             return web.json_response(result)
             
         except Exception as e:
@@ -355,7 +375,100 @@ class RecipeRoutes:
                     os.unlink(temp_path)
                 except Exception as e:
                     logger.error(f"Error deleting temporary file: {e}")
+    
+    async def analyze_local_image(self, request: web.Request) -> web.Response:
+        """Analyze a local image file for recipe metadata"""
+        try:
+            # Ensure services are initialized 
+            await self.init_services()
+            
+            # Get JSON data from request
+            data = await request.json()
+            file_path = data.get('path')
+            
+            if not file_path:
+                return web.json_response({
+                    'error': 'No file path provided',
+                    'loras': []
+                }, status=400)
+                
+            # Normalize file path for cross-platform compatibility
+            file_path = os.path.normpath(file_path.strip('"').strip("'"))
+            
+            # Validate that the file exists
+            if not os.path.isfile(file_path):
+                return web.json_response({
+                    'error': 'File not found',
+                    'loras': []
+                }, status=404)
+                
+            # Extract metadata from the image using ExifUtils
+            metadata = ExifUtils.extract_image_metadata(file_path)
+            
+            # If no metadata found, return error
+            if not metadata:
+                # Get base64 image data
+                with open(file_path, "rb") as image_file:
+                    image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
+                    
+                return web.json_response({
+                    "error": "No metadata found in this image",
+                    "loras": [],  # Return empty loras array to prevent client-side errors
+                    "image_base64": image_base64
+                }, status=200)
+            
+            # Use the parser factory to get the appropriate parser
+            parser = RecipeParserFactory.create_parser(metadata)
 
+            if parser is None:
+                # Get base64 image data
+                with open(file_path, "rb") as image_file:
+                    image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
+                    
+                return web.json_response({
+                    "error": "No parser found for this image",
+                    "loras": [],  # Return empty loras array to prevent client-side errors
+                    "image_base64": image_base64
+                }, status=200)
+            
+            # Parse the metadata
+            result = await parser.parse_metadata(
+                metadata, 
+                recipe_scanner=self.recipe_scanner, 
+                civitai_client=self.civitai_client
+            )
+            
+            # Add base64 image data to result
+            with open(file_path, "rb") as image_file:
+                result["image_base64"] = base64.b64encode(image_file.read()).decode('utf-8')
+            
+            # Check for errors
+            if "error" in result and not result.get("loras"):
+                return web.json_response(result, status=200)
+            
+            # Calculate fingerprint from parsed loras
+            from ..utils.utils import calculate_recipe_fingerprint
+            fingerprint = calculate_recipe_fingerprint(result.get("loras", []))
+            
+            # Add fingerprint to result
+            result["fingerprint"] = fingerprint
+            
+            # Find matching recipes with the same fingerprint
+            matching_recipes = []
+            if fingerprint:
+                matching_recipes = await self.recipe_scanner.find_recipes_by_fingerprint(fingerprint)
+                
+            # Add matching recipes to result
+            result["matching_recipes"] = matching_recipes
+            
+            return web.json_response(result)
+            
+        except Exception as e:
+            logger.error(f"Error analyzing local image: {e}", exc_info=True)
+            return web.json_response({
+                'error': str(e),
+                'loras': []  # Return empty loras array to prevent client-side errors
+            }, status=500)
 
     async def save_recipe(self, request: web.Request) -> web.Response:
         """Save a recipe to the recipes folder"""
@@ -425,7 +538,6 @@ class RecipeRoutes:
             if not image:
                 if image_base64:
                     # Convert base64 to binary
-                    import base64
                     try:
                         # Remove potential data URL prefix
                         if ',' in image_base64:
@@ -474,7 +586,7 @@ class RecipeRoutes:
             with open(image_path, 'wb') as f:
                 f.write(optimized_image)
             
-            # Create the recipe JSON
+            # Create the recipe data structure
             current_time = time.time()
             
             # Format loras data according to the recipe.json format
@@ -514,6 +626,10 @@ class RecipeRoutes:
                     "clip_skip": raw_metadata.get("clip_skip", "")
                 }
             
+            # Calculate recipe fingerprint 
+            from ..utils.utils import calculate_recipe_fingerprint
+            fingerprint = calculate_recipe_fingerprint(loras_data)
+            
             # Create the recipe data structure
             recipe_data = {
                 "id": recipe_id,
@@ -523,13 +639,18 @@ class RecipeRoutes:
                 "created_date": current_time,
                 "base_model": metadata.get("base_model", ""),
                 "loras": loras_data,
-                "gen_params": gen_params
+                "gen_params": gen_params,
+                "fingerprint": fingerprint
             }
             
             # Add tags if provided
             if tags:
                 recipe_data["tags"] = tags
             
+            # Add source_path if provided in metadata
+            if metadata.get("source_path"):
+                recipe_data["source_path"] = metadata.get("source_path")
+            
             # Save the recipe JSON
             json_filename = f"{recipe_id}.recipe.json"
             json_path = os.path.join(recipes_dir, json_filename)
@@ -539,6 +660,14 @@ class RecipeRoutes:
             # Add recipe metadata to the image
             ExifUtils.append_recipe_metadata(image_path, recipe_data)
             
+            # Check for duplicates
+            matching_recipes = []
+            if fingerprint:
+                matching_recipes = await self.recipe_scanner.find_recipes_by_fingerprint(fingerprint)
+                # Remove current recipe from matches
+                if recipe_id in matching_recipes:
+                    matching_recipes.remove(recipe_id)
+            
             # Simplified cache update approach
             # Instead of trying to update the cache directly, just set it to None
             # to force a refresh on the next get_cached_data call
@@ -554,7 +683,8 @@ class RecipeRoutes:
                 'success': True,
                 'recipe_id': recipe_id,
                 'image_path': image_path,
-                'json_path': json_path
+                'json_path': json_path,
+                'matching_recipes': matching_recipes
             })
             
         except Exception as e:
@@ -1089,9 +1219,9 @@ class RecipeRoutes:
             data = await request.json()
             
             # Validate required fields
-            if 'title' not in data and 'tags' not in data:
+            if 'title' not in data and 'tags' not in data and 'source_path' not in data:
                 return web.json_response({
-                    "error": "At least one field to update must be provided (title or tags)"
+                    "error": "At least one field to update must be provided (title or tags or source_path)"
                 }, status=400)
             
             # Use the recipe scanner's update method
@@ -1186,6 +1316,10 @@ class RecipeRoutes:
                     
             if not found:
                 return web.json_response({"error": "Could not find matching deleted LoRA in recipe"}, status=404)
+            
+            # Recalculate recipe fingerprint after updating LoRA
+            from ..utils.utils import calculate_recipe_fingerprint
+            recipe_data['fingerprint'] = calculate_recipe_fingerprint(recipe_data.get('loras', []))
                 
             # Save updated recipe
             with open(recipe_path, 'w', encoding='utf-8') as f:
@@ -1201,6 +1335,8 @@ class RecipeRoutes:
                     if cache_item.get('id') == recipe_id:
                         # Replace loras array with updated version
                         cache_item['loras'] = recipe_data['loras']
+                        # Update fingerprint in cache
+                        cache_item['fingerprint'] = recipe_data['fingerprint']
                         
                         # Resort the cache
                         asyncio.create_task(scanner._cache.resort())
@@ -1211,11 +1347,20 @@ class RecipeRoutes:
             if image_path and os.path.exists(image_path):
                 from ..utils.exif_utils import ExifUtils
                 ExifUtils.append_recipe_metadata(image_path, recipe_data)
+            
+            # Find other recipes with the same fingerprint
+            matching_recipes = []
+            if 'fingerprint' in recipe_data:
+                matching_recipes = await scanner.find_recipes_by_fingerprint(recipe_data['fingerprint'])
+                # Remove current recipe from matches
+                if recipe_id in matching_recipes:
+                    matching_recipes.remove(recipe_id)
                 
             return web.json_response({
                 "success": True,
                 "recipe_id": recipe_id,
-                "updated_lora": updated_lora
+                "updated_lora": updated_lora,
+                "matching_recipes": matching_recipes
             })
             
         except Exception as e:
@@ -1291,3 +1436,150 @@ class RecipeRoutes:
                 'success': False,
                 'error': str(e)
             }, status=500)
+
+    async def find_duplicates(self, request: web.Request) -> web.Response:
+        """Find all duplicate recipes based on fingerprints"""
+        try:
+            # Ensure services are initialized
+            await self.init_services()
+            
+            # Get all duplicate recipes
+            duplicate_groups = await self.recipe_scanner.find_all_duplicate_recipes()
+            
+            # Create response data with additional recipe information
+            response_data = []
+            
+            for fingerprint, recipe_ids in duplicate_groups.items():
+                # Skip groups with only one recipe (not duplicates)
+                if len(recipe_ids) <= 1:
+                    continue
+                    
+                # Get recipe details for each recipe in the group
+                recipes = []
+                for recipe_id in recipe_ids:
+                    recipe = await self.recipe_scanner.get_recipe_by_id(recipe_id)
+                    if recipe:
+                        # Add only needed fields to keep response size manageable
+                        recipes.append({
+                            'id': recipe.get('id'),
+                            'title': recipe.get('title'),
+                            'file_url': recipe.get('file_url') or self._format_recipe_file_url(recipe.get('file_path', '')),
+                            'modified': recipe.get('modified'),
+                            'created_date': recipe.get('created_date'),
+                            'lora_count': len(recipe.get('loras', [])),
+                        })
+                        
+                # Only include groups with at least 2 valid recipes
+                if len(recipes) >= 2:
+                    # Sort recipes by modified date (newest first)
+                    recipes.sort(key=lambda x: x.get('modified', 0), reverse=True)
+                    
+                    response_data.append({
+                        'fingerprint': fingerprint,
+                        'count': len(recipes),
+                        'recipes': recipes
+                    })
+            
+            # Sort groups by count (highest first)
+            response_data.sort(key=lambda x: x['count'], reverse=True)
+            
+            return web.json_response({
+                'success': True,
+                'duplicate_groups': response_data
+            })
+            
+        except Exception as e:
+            logger.error(f"Error finding duplicate recipes: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)
+    
+    async def bulk_delete(self, request: web.Request) -> web.Response:
+        """Delete multiple recipes by ID"""
+        try:
+            # Ensure services are initialized
+            await self.init_services()
+            
+            # Parse request data
+            data = await request.json()
+            recipe_ids = data.get('recipe_ids', [])
+            
+            if not recipe_ids:
+                return web.json_response({
+                    'success': False,
+                    'error': 'No recipe IDs provided'
+                }, status=400)
+                
+            # Get recipes directory
+            recipes_dir = self.recipe_scanner.recipes_dir
+            if not recipes_dir or not os.path.exists(recipes_dir):
+                return web.json_response({
+                    'success': False,
+                    'error': 'Recipes directory not found'
+                }, status=404)
+            
+            # Track deleted and failed recipes
+            deleted_recipes = []
+            failed_recipes = []
+            
+            # Process each recipe ID
+            for recipe_id in recipe_ids:
+                # Find recipe JSON file
+                recipe_json_path = os.path.join(recipes_dir, f"{recipe_id}.recipe.json")
+                
+                if not os.path.exists(recipe_json_path):
+                    failed_recipes.append({
+                        'id': recipe_id,
+                        'reason': 'Recipe not found'
+                    })
+                    continue
+                
+                try:
+                    # Load recipe data to get image path
+                    with open(recipe_json_path, 'r', encoding='utf-8') as f:
+                        recipe_data = json.load(f)
+                    
+                    # Get image path
+                    image_path = recipe_data.get('file_path')
+                    
+                    # Delete recipe JSON file
+                    os.remove(recipe_json_path)
+                    
+                    # Delete recipe image if it exists
+                    if image_path and os.path.exists(image_path):
+                        os.remove(image_path)
+                        
+                    deleted_recipes.append(recipe_id)
+                    
+                except Exception as e:
+                    failed_recipes.append({
+                        'id': recipe_id,
+                        'reason': str(e)
+                    })
+            
+            # Update cache if any recipes were deleted
+            if deleted_recipes and self.recipe_scanner._cache is not None:
+                # Remove deleted recipes from raw_data
+                self.recipe_scanner._cache.raw_data = [
+                    r for r in self.recipe_scanner._cache.raw_data 
+                    if r.get('id') not in deleted_recipes
+                ]
+                # Resort the cache
+                asyncio.create_task(self.recipe_scanner._cache.resort())
+                logger.info(f"Removed {len(deleted_recipes)} recipes from cache")
+            
+            return web.json_response({
+                'success': True,
+                'deleted': deleted_recipes,
+                'failed': failed_recipes,
+                'total_deleted': len(deleted_recipes),
+                'total_failed': len(failed_recipes)
+            })
+            
+        except Exception as e:
+            logger.error(f"Error performing bulk delete: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)

py/routes/update_routes.py

@@ -150,11 +150,16 @@ class UpdateRoutes:
         """
         Compare two semantic version strings
         Returns True if version2 is newer than version1
+        Ignores any suffixes after '-' (e.g., -bugfix, -alpha)
         """
         try:
+            # Clean version strings - remove any suffix after '-'
+            v1_clean = version1.split('-')[0]
+            v2_clean = version2.split('-')[0]
+            
             # Split versions into components
-            v1_parts = [int(x) for x in version1.split('.')]
-            v2_parts = [int(x) for x in version2.split('.')]
+            v1_parts = [int(x) for x in v1_clean.split('.')]
+            v2_parts = [int(x) for x in v2_clean.split('.')]
             
             # Ensure both have 3 components (major.minor.patch)
             while len(v1_parts) < 3:

py/server_routes.py

@@ -1,26 +0,0 @@
-from aiohttp import web
-from server import PromptServer
-from .nodes.utils import get_lora_info
-
-@PromptServer.instance.routes.post("/loramanager/get_trigger_words")
-async def get_trigger_words(request):
-    json_data = await request.json()
-    lora_names = json_data.get("lora_names", [])
-    node_ids = json_data.get("node_ids", [])
-    
-    all_trigger_words = []
-    for lora_name in lora_names:
-        _, trigger_words = await get_lora_info(lora_name)
-        all_trigger_words.extend(trigger_words)
-    
-    # Format the trigger words
-    trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
-    
-    # Send update to all connected trigger word toggle nodes
-    for node_id in node_ids:
-        PromptServer.instance.send_sync("trigger_word_update", {
-            "id": node_id,
-            "message": trigger_words_text
-        })
-    
-    return web.json_response({"success": True})

py/services/civitai_client.py

@@ -267,7 +267,7 @@ class CivitaiClient:
             return None, error_msg
 
     async def get_model_metadata(self, model_id: str) -> Tuple[Optional[Dict], int]:
-        """Fetch model metadata (description and tags) from Civitai API
+        """Fetch model metadata (description, tags, and creator info) from Civitai API
         
         Args:
             model_id: The Civitai model ID
@@ -294,10 +294,14 @@ class CivitaiClient:
                 # Extract relevant metadata
                 metadata = {
                     "description": data.get("description") or "No model description available",
-                    "tags": data.get("tags", [])
+                    "tags": data.get("tags", []),
+                    "creator": {
+                        "username": data.get("creator", {}).get("username"),
+                        "image": data.get("creator", {}).get("image")
+                    }
                 }
                 
-                if metadata["description"] or metadata["tags"]:
+                if metadata["description"] or metadata["tags"] or metadata["creator"]["username"]:
                     return metadata, status_code
                 else:
                     logger.warning(f"No metadata found for model {model_id}")

py/services/download_manager.py

@@ -136,15 +136,9 @@ class DownloadManager:
             # 3. Prepare download
             file_name = file_info['name']
             save_path = os.path.join(save_dir, file_name)
-            file_size = file_info.get('sizeKB', 0) * 1024
 
             # 4. Notify file monitor - use normalized path and file size
-            file_monitor = await self._get_lora_monitor() if model_type == "lora" else await self._get_checkpoint_monitor()
-            if file_monitor and file_monitor.handler:
-                file_monitor.handler.add_ignore_path(
-                    save_path.replace(os.sep, '/'),
-                    file_size
-                )
+            # file monitor is despreted, so we don't need to use it
 
             # 5. Prepare metadata based on model type
             if model_type == "checkpoint":
@@ -154,7 +148,7 @@ class DownloadManager:
                 metadata = LoraMetadata.from_civitai_info(version_info, file_info, save_path)
                 logger.info(f"Creating LoraMetadata for {file_name}")
             
-            # 5.1 Get and update model tags and description
+            # 5.1 Get and update model tags, description and creator info
             model_id = version_info.get('modelId')
             if model_id:
                 model_metadata, _ = await civitai_client.get_model_metadata(str(model_id))
@@ -163,6 +157,8 @@ class DownloadManager:
                         metadata.tags = model_metadata.get("tags", [])
                     if model_metadata.get("description"):
                         metadata.modelDescription = model_metadata.get("description", "")
+                    if model_metadata.get("creator"):
+                        metadata.civitai["creator"] = model_metadata.get("creator")
             
             # 6. Start download process
             result = await self._execute_download(

py/services/lora_cache.py

@@ -2,6 +2,7 @@ import asyncio
 from typing import List, Dict
 from dataclasses import dataclass
 from operator import itemgetter
+from natsort import natsorted
 
 @dataclass
 class LoraCache:
@@ -17,7 +18,7 @@ class LoraCache:
     async def resort(self, name_only: bool = False):
         """Resort all cached data views"""
         async with self._lock:
-            self.sorted_by_name = sorted(
+            self.sorted_by_name = natsorted(
                 self.raw_data, 
                 key=lambda x: x['model_name'].lower()  # Case-insensitive sort
             )

py/services/lora_scanner.py

@@ -4,6 +4,7 @@ import logging
 import asyncio
 import shutil
 import time
+import re
 from typing import List, Dict, Optional, Set
 
 from ..utils.models import LoraMetadata
@@ -123,7 +124,7 @@ class LoraScanner(ModelScanner):
                                folder: str = None, search: str = None, fuzzy_search: bool = False,
                                base_models: list = None, tags: list = None,
                                search_options: dict = None, hash_filters: dict = None,
-                               favorites_only: bool = False) -> Dict:
+                               favorites_only: bool = False, first_letter: str = None) -> Dict:
         """Get paginated and filtered lora data
         
         Args:
@@ -138,6 +139,7 @@ class LoraScanner(ModelScanner):
             search_options: Dictionary with search options (filename, modelname, tags, recursive)
             hash_filters: Dictionary with hash filtering options (single_hash or multiple_hashes)
             favorites_only: Filter for favorite models only
+            first_letter: Filter by first letter of model name
         """
         cache = await self.get_cached_data()
 
@@ -202,6 +204,10 @@ class LoraScanner(ModelScanner):
                 lora for lora in filtered_data
                 if lora.get('favorite', False) is True
             ]
+            
+        # Apply first letter filtering
+        if first_letter:
+            filtered_data = self._filter_by_first_letter(filtered_data, first_letter)
         
         # Apply folder filtering
         if folder is not None:
@@ -273,6 +279,101 @@ class LoraScanner(ModelScanner):
         
         return result
 
+    def _filter_by_first_letter(self, data, letter):
+        """Filter data by first letter of model name
+        
+        Special handling:
+        - '#': Numbers (0-9)
+        - '@': Special characters (not alphanumeric)
+        - '漢': CJK characters
+        """
+        filtered_data = []
+        
+        for lora in data:
+            model_name = lora.get('model_name', '')
+            if not model_name:
+                continue
+                
+            first_char = model_name[0].upper()
+            
+            if letter == '#' and first_char.isdigit():
+                filtered_data.append(lora)
+            elif letter == '@' and not first_char.isalnum():
+                # Special characters (not alphanumeric)
+                filtered_data.append(lora)
+            elif letter == '漢' and self._is_cjk_character(first_char):
+                # CJK characters
+                filtered_data.append(lora)
+            elif letter.upper() == first_char:
+                # Regular alphabet matching
+                filtered_data.append(lora)
+                
+        return filtered_data
+    
+    def _is_cjk_character(self, char):
+        """Check if character is a CJK character"""
+        # Define Unicode ranges for CJK characters
+        cjk_ranges = [
+            (0x4E00, 0x9FFF),   # CJK Unified Ideographs
+            (0x3400, 0x4DBF),   # CJK Unified Ideographs Extension A
+            (0x20000, 0x2A6DF), # CJK Unified Ideographs Extension B
+            (0x2A700, 0x2B73F), # CJK Unified Ideographs Extension C
+            (0x2B740, 0x2B81F), # CJK Unified Ideographs Extension D
+            (0x2B820, 0x2CEAF), # CJK Unified Ideographs Extension E
+            (0x2CEB0, 0x2EBEF), # CJK Unified Ideographs Extension F
+            (0x30000, 0x3134F), # CJK Unified Ideographs Extension G
+            (0xF900, 0xFAFF),   # CJK Compatibility Ideographs
+            (0x3300, 0x33FF),   # CJK Compatibility
+            (0x3200, 0x32FF),   # Enclosed CJK Letters and Months
+            (0x3100, 0x312F),   # Bopomofo
+            (0x31A0, 0x31BF),   # Bopomofo Extended
+            (0x3040, 0x309F),   # Hiragana
+            (0x30A0, 0x30FF),   # Katakana
+            (0x31F0, 0x31FF),   # Katakana Phonetic Extensions
+            (0xAC00, 0xD7AF),   # Hangul Syllables
+            (0x1100, 0x11FF),   # Hangul Jamo
+            (0xA960, 0xA97F),   # Hangul Jamo Extended-A
+            (0xD7B0, 0xD7FF),   # Hangul Jamo Extended-B
+        ]
+        
+        code_point = ord(char)
+        return any(start <= code_point <= end for start, end in cjk_ranges)
+    
+    async def get_letter_counts(self):
+        """Get count of models for each letter of the alphabet"""
+        cache = await self.get_cached_data()
+        data = cache.sorted_by_name
+        
+        # Define letter categories
+        letters = {
+            '#': 0,  # Numbers
+            'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'F': 0, 'G': 0, 'H': 0,
+            'I': 0, 'J': 0, 'K': 0, 'L': 0, 'M': 0, 'N': 0, 'O': 0, 'P': 0,
+            'Q': 0, 'R': 0, 'S': 0, 'T': 0, 'U': 0, 'V': 0, 'W': 0, 'X': 0,
+            'Y': 0, 'Z': 0,
+            '@': 0,  # Special characters
+            '漢': 0   # CJK characters
+        }
+        
+        # Count models for each letter
+        for lora in data:
+            model_name = lora.get('model_name', '')
+            if not model_name:
+                continue
+                
+            first_char = model_name[0].upper()
+            
+            if first_char.isdigit():
+                letters['#'] += 1
+            elif first_char in letters:
+                letters[first_char] += 1
+            elif self._is_cjk_character(first_char):
+                letters['漢'] += 1
+            elif not first_char.isalnum():
+                letters['@'] += 1
+                
+        return letters
+
     async def _update_metadata_paths(self, metadata_path: str, lora_path: str) -> Dict:
         """Update file paths in metadata file"""
         try:

py/services/model_cache.py

@@ -2,6 +2,7 @@ import asyncio
 from typing import List, Dict
 from dataclasses import dataclass
 from operator import itemgetter
+from natsort import natsorted
 
 @dataclass
 class ModelCache:
@@ -17,7 +18,7 @@ class ModelCache:
     async def resort(self, name_only: bool = False):
         """Resort all cached data views"""
         async with self._lock:
-            self.sorted_by_name = sorted(
+            self.sorted_by_name = natsorted(
                 self.raw_data, 
                 key=lambda x: x['model_name'].lower()  # Case-insensitive sort
             )

py/services/model_scanner.py

@@ -38,6 +38,7 @@ class ModelScanner:
         self._hash_index = hash_index or ModelHashIndex()
         self._tags_count = {}  # Dictionary to store tag counts
         self._is_initializing = False  # Flag to track initialization state
+        self._excluded_models = []  # List to track excluded models
         
         # Register this service
         asyncio.create_task(self._register_service())
@@ -394,6 +395,9 @@ class ModelScanner:
                             if file_path in cached_paths:
                                 found_paths.add(file_path)
                                 continue
+
+                            if file_path in self._excluded_models:
+                                continue
                                 
                             # Try case-insensitive match on Windows
                             if os.name == 'nt':
@@ -406,7 +410,7 @@ class ModelScanner:
                                         break
                                 if matched:
                                     continue
-                            
+                                
                             # This is a new file to process
                             new_files.append(file_path)
                     
@@ -586,6 +590,11 @@ class ModelScanner:
         
         model_data = metadata.to_dict()
         
+        # Skip excluded models
+        if model_data.get('exclude', False):
+            self._excluded_models.append(model_data['file_path'])
+            return None
+            
         await self._fetch_missing_metadata(file_path, model_data)
         rel_path = os.path.relpath(file_path, root_path)
         folder = os.path.dirname(rel_path)
@@ -610,7 +619,10 @@ class ModelScanner:
                     model_id = str(model_id)
                     tags_missing = not model_data.get('tags') or len(model_data.get('tags', [])) == 0
                     desc_missing = not model_data.get('modelDescription') or model_data.get('modelDescription') in (None, "")
-                    needs_metadata_update = tags_missing or desc_missing
+                    # TODO: not for now, but later we should check if the creator is missing
+                    # creator_missing = not model_data.get('civitai', {}).get('creator')
+                    creator_missing = False
+                    needs_metadata_update = tags_missing or desc_missing or creator_missing
             
             if needs_metadata_update and model_id:
                 logger.debug(f"Fetching missing metadata for {file_path} with model ID {model_id}")
@@ -636,6 +648,8 @@ class ModelScanner:
                     
                     if model_metadata.get('description') and (not model_data.get('modelDescription') or model_data.get('modelDescription') in (None, "")):
                         model_data['modelDescription'] = model_metadata['description']
+
+                    model_data['civitai']['creator'] = model_metadata['creator']
                     
                     metadata_path = os.path.splitext(file_path)[0] + '.metadata.json'
                     with open(metadata_path, 'w', encoding='utf-8') as f:
@@ -900,6 +914,10 @@ class ModelScanner:
             logger.error(f"Error getting model info by name: {e}", exc_info=True)
             return None
         
+    def get_excluded_models(self) -> List[str]:
+        """Get list of excluded model file paths"""
+        return self._excluded_models.copy()
+
     async def update_preview_in_cache(self, file_path: str, preview_url: str) -> bool:
         """Update preview URL in cache for a specific lora
         
@@ -913,4 +931,4 @@ class ModelScanner:
         if self._cache is None:
             return False
 
-        return await self._cache.update_preview_url(file_path, preview_url)
+        return await self._cache.update_preview_url(file_path, preview_url)

py/services/recipe_cache.py

@@ -2,6 +2,7 @@ import asyncio
 from typing import List, Dict
 from dataclasses import dataclass
 from operator import itemgetter
+from natsort import natsorted
 
 @dataclass
 class RecipeCache:
@@ -16,7 +17,7 @@ class RecipeCache:
     async def resort(self, name_only: bool = False):
         """Resort all cached data views"""
         async with self._lock:
-            self.sorted_by_name = sorted(
+            self.sorted_by_name = natsorted(
                 self.raw_data, 
                 key=lambda x: x.get('title', '').lower()  # Case-insensitive sort
             )

py/services/recipe_scanner.py

@@ -9,6 +9,7 @@ from .recipe_cache import RecipeCache
 from .service_registry import ServiceRegistry
 from .lora_scanner import LoraScanner
 from ..utils.utils import fuzzy_match
+from natsort import natsorted
 import sys
 
 logger = logging.getLogger(__name__)
@@ -164,7 +165,7 @@ class RecipeScanner:
                 if hasattr(self._cache, "resort"):
                     try:
                         # Sort by name
-                        self._cache.sorted_by_name = sorted(
+                        self._cache.sorted_by_name = natsorted(
                             self._cache.raw_data,
                             key=lambda x: x.get('title', '').lower()
                         )
@@ -321,6 +322,20 @@ class RecipeScanner:
             
             # Update lora information with local paths and availability
             await self._update_lora_information(recipe_data)
+
+            # Calculate and update fingerprint if missing
+            if 'loras' in recipe_data and 'fingerprint' not in recipe_data:
+                from ..utils.utils import calculate_recipe_fingerprint
+                fingerprint = calculate_recipe_fingerprint(recipe_data['loras'])
+                recipe_data['fingerprint'] = fingerprint
+                
+                # Write updated recipe data back to file
+                try:
+                    with open(recipe_path, 'w', encoding='utf-8') as f:
+                        json.dump(recipe_data, f, indent=4, ensure_ascii=False)
+                    logger.info(f"Added fingerprint to recipe: {recipe_path}")
+                except Exception as e:
+                    logger.error(f"Error writing updated recipe with fingerprint: {e}")
             
             return recipe_data
         except Exception as e:
@@ -801,3 +816,60 @@ class RecipeScanner:
             logger.info(f"Resorted recipe cache after updating {cache_updated_count} items")
             
         return file_updated_count, cache_updated_count
+
+    async def find_recipes_by_fingerprint(self, fingerprint: str) -> list:
+        """Find recipes with a matching fingerprint
+        
+        Args:
+            fingerprint: The recipe fingerprint to search for
+            
+        Returns:
+            List of recipe details that match the fingerprint
+        """
+        if not fingerprint:
+            return []
+            
+        # Get all recipes from cache
+        cache = await self.get_cached_data()
+        
+        # Find recipes with matching fingerprint
+        matching_recipes = []
+        for recipe in cache.raw_data:
+            if recipe.get('fingerprint') == fingerprint:
+                recipe_details = {
+                    'id': recipe.get('id'),
+                    'title': recipe.get('title'),
+                    'file_url': self._format_file_url(recipe.get('file_path')),
+                    'modified': recipe.get('modified'),
+                    'created_date': recipe.get('created_date'),
+                    'lora_count': len(recipe.get('loras', []))
+                }
+                matching_recipes.append(recipe_details)
+        
+        return matching_recipes
+        
+    async def find_all_duplicate_recipes(self) -> dict:
+        """Find all recipe duplicates based on fingerprints
+        
+        Returns:
+            Dictionary where keys are fingerprints and values are lists of recipe IDs
+        """
+        # Get all recipes from cache
+        cache = await self.get_cached_data()
+        
+        # Group recipes by fingerprint
+        fingerprint_groups = {}
+        for recipe in cache.raw_data:
+            fingerprint = recipe.get('fingerprint')
+            if not fingerprint:
+                continue
+                
+            if fingerprint not in fingerprint_groups:
+                fingerprint_groups[fingerprint] = []
+                
+            fingerprint_groups[fingerprint].append(recipe.get('id'))
+        
+        # Filter to only include groups with more than one recipe
+        duplicate_groups = {k: v for k, v in fingerprint_groups.items() if len(v) > 1}
+        
+        return duplicate_groups

py/utils/file_utils.py

@@ -233,6 +233,17 @@ async def load_metadata(file_path: str, model_class: Type[BaseModelMetadata] = L
                     data['usage_tips'] = "{}"
                     needs_update = True
                 
+                # Update preview_nsfw_level if needed
+                civitai_data = data.get('civitai', {})
+                civitai_images = civitai_data.get('images', []) if civitai_data else []
+                if (data.get('preview_url') and 
+                    data.get('preview_nsfw_level', 0) == 0 and 
+                    civitai_images and 
+                    civitai_images[0].get('nsfwLevel', 0) != 0):
+                    data['preview_nsfw_level'] = civitai_images[0]['nsfwLevel']
+                    # TODO: write to metadata file
+                    # needs_update = True
+
                 if needs_update:
                     with open(metadata_path, 'w', encoding='utf-8') as f:
                         json.dump(data, f, indent=2, ensure_ascii=False)

py/utils/lora_metadata.py

@@ -2,6 +2,9 @@ from safetensors import safe_open
 from typing import Dict
 from .model_utils import determine_base_model
 import os
+import logging
+
+logger = logging.getLogger(__name__)
 
 async def extract_lora_metadata(file_path: str) -> Dict:
     """Extract essential metadata from safetensors file"""

py/utils/models.py

@@ -23,6 +23,7 @@ class BaseModelMetadata:
     modelDescription: str = ""  # Full model description
     civitai_deleted: bool = False  # Whether deleted from Civitai
     favorite: bool = False      # Whether the model is a favorite
+    exclude: bool = False       # Whether to exclude this model from the cache
 
     def __post_init__(self):
         # Initialize empty lists to avoid mutable default parameter issue

py/utils/routes_common.py

@@ -53,6 +53,7 @@ class ModelRouteUtils:
                 if model_metadata:
                     local_metadata['modelDescription'] = model_metadata.get('description', '')
                     local_metadata['tags'] = model_metadata.get('tags', [])
+                    local_metadata['civitai']['creator'] = model_metadata['creator']
         
         # Update base model
         local_metadata['base_model'] = determine_base_model(civitai_metadata.get('baseModel'))
@@ -424,6 +425,65 @@ class ModelRouteUtils:
             logger.error(f"Error replacing preview: {e}", exc_info=True)
             return web.Response(text=str(e), status=500)
 
+    @staticmethod
+    async def handle_exclude_model(request: web.Request, scanner) -> web.Response:
+        """Handle model exclusion request
+        
+        Args:
+            request: The aiohttp request
+            scanner: The model scanner instance with cache management methods
+            
+        Returns:
+            web.Response: The HTTP response
+        """
+        try:
+            data = await request.json()
+            file_path = data.get('file_path')
+            if not file_path:
+                return web.Response(text='Model path is required', status=400)
+
+            # Update metadata to mark as excluded
+            metadata_path = os.path.splitext(file_path)[0] + '.metadata.json'
+            metadata = await ModelRouteUtils.load_local_metadata(metadata_path)
+            metadata['exclude'] = True
+            
+            # Save updated metadata
+            with open(metadata_path, 'w', encoding='utf-8') as f:
+                json.dump(metadata, f, indent=2, ensure_ascii=False)
+
+            # Update cache
+            cache = await scanner.get_cached_data()
+
+            # Find and remove model from cache
+            model_to_remove = next((item for item in cache.raw_data if item['file_path'] == file_path), None)
+            if model_to_remove:
+                # Update tags count
+                for tag in model_to_remove.get('tags', []):
+                    if tag in scanner._tags_count:
+                        scanner._tags_count[tag] = max(0, scanner._tags_count[tag] - 1)
+                        if scanner._tags_count[tag] == 0:
+                            del scanner._tags_count[tag]
+
+                # Remove from hash index if available
+                if hasattr(scanner, '_hash_index') and scanner._hash_index:
+                    scanner._hash_index.remove_by_path(file_path)
+
+                # Remove from cache data
+                cache.raw_data = [item for item in cache.raw_data if item['file_path'] != file_path]
+                await cache.resort()
+            
+            # Add to excluded models list
+            scanner._excluded_models.append(file_path)
+            
+            return web.json_response({
+                'success': True,
+                'message': f"Model {os.path.basename(file_path)} excluded"
+            })
+            
+        except Exception as e:
+            logger.error(f"Error excluding model: {e}", exc_info=True)
+            return web.Response(text=str(e), status=500)
+
     @staticmethod
     async def handle_download_model(request: web.Request, download_manager: DownloadManager, model_type="lora") -> web.Response:
         """Handle model download request
@@ -500,4 +560,4 @@ class ModelRouteUtils:
                 )
             
             logger.error(f"Error downloading {model_type}: {error_message}")
-            return web.Response(status=500, text=error_message)
+            return web.Response(status=500, text=error_message)

py/utils/utils.py

@@ -114,3 +114,49 @@ def fuzzy_match(text: str, pattern: str, threshold: float = 0.7) -> bool:
         
         # All words found either as substrings or fuzzy matches
         return True
+
+def calculate_recipe_fingerprint(loras):
+    """
+    Calculate a unique fingerprint for a recipe based on its LoRAs.
+    
+    The fingerprint is created by sorting LoRA hashes, filtering invalid entries,
+    normalizing strength values to 2 decimal places, and joining in format:
+    hash1:strength1|hash2:strength2|...
+    
+    Args:
+        loras (list): List of LoRA dictionaries with hash and strength values
+        
+    Returns:
+        str: The calculated fingerprint
+    """
+    if not loras:
+        return ""
+    
+    # Filter valid entries and extract hash and strength
+    valid_loras = []
+    for lora in loras:
+        # Skip excluded loras
+        if lora.get("exclude", False):
+            continue
+            
+        # Get the hash - use modelVersionId as fallback if hash is empty
+        hash_value = lora.get("hash", "").lower()
+        if not hash_value and lora.get("isDeleted", False) and lora.get("modelVersionId"):
+            hash_value = lora.get("modelVersionId")
+            
+        # Skip entries without a valid hash
+        if not hash_value:
+            continue
+            
+        # Normalize strength to 2 decimal places (check both strength and weight fields)
+        strength = round(float(lora.get("strength", lora.get("weight", 1.0))), 2)
+        
+        valid_loras.append((hash_value, strength))
+    
+    # Sort by hash
+    valid_loras.sort()
+    
+    # Join in format hash1:strength1|hash2:strength2|...
+    fingerprint = "|".join([f"{hash_value}:{strength}" for hash_value, strength in valid_loras])
+    
+    return fingerprint

py/workflow/__init__.py

@@ -1,3 +0,0 @@
-"""
-ComfyUI workflow parsing module to extract generation parameters
-""" 

py/workflow/cli.py

@@ -1,58 +0,0 @@
-"""
-Command-line interface for the ComfyUI workflow parser
-"""
-import argparse
-import json
-import os
-import logging
-import sys
-from .parser import parse_workflow
-
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler()]
-)
-logger = logging.getLogger(__name__)
-
-def main():
-    """Entry point for the CLI"""
-    parser = argparse.ArgumentParser(description='Parse ComfyUI workflow files')
-    parser.add_argument('input', help='Input workflow JSON file path')
-    parser.add_argument('-o', '--output', help='Output JSON file path')
-    parser.add_argument('-p', '--pretty', action='store_true', help='Pretty print JSON output')
-    parser.add_argument('--debug', action='store_true', help='Enable debug logging')
-    
-    args = parser.parse_args()
-    
-    # Set logging level
-    if args.debug:
-        logging.getLogger().setLevel(logging.DEBUG)
-    
-    # Validate input file
-    if not os.path.isfile(args.input):
-        logger.error(f"Input file not found: {args.input}")
-        sys.exit(1)
-    
-    # Parse workflow
-    try:
-        result = parse_workflow(args.input, args.output)
-        
-        # Print result to console if output file not specified
-        if not args.output:
-            if args.pretty:
-                print(json.dumps(result, indent=4))
-            else:
-                print(json.dumps(result))
-        else:
-            logger.info(f"Output saved to: {args.output}")
-            
-    except Exception as e:
-        logger.error(f"Error parsing workflow: {e}")
-        if args.debug:
-            import traceback
-            traceback.print_exc()
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main() 

py/workflow/ext/__init__.py

@@ -1,3 +0,0 @@
-"""
-Extension directory for custom node mappers
-""" 

py/workflow/ext/comfyui_core.py

@@ -1,285 +0,0 @@
-"""
-ComfyUI Core nodes mappers extension for workflow parsing
-"""
-import logging
-from typing import Dict, Any, List
-
-logger = logging.getLogger(__name__)
-
-# =============================================================================
-# Transform Functions
-# =============================================================================
-
-def transform_random_noise(inputs: Dict) -> Dict:
-    """Transform function for RandomNoise node"""
-    return {"seed": str(inputs.get("noise_seed", ""))}
-
-def transform_ksampler_select(inputs: Dict) -> Dict:
-    """Transform function for KSamplerSelect node"""
-    return {"sampler": inputs.get("sampler_name", "")}
-
-def transform_basic_scheduler(inputs: Dict) -> Dict:
-    """Transform function for BasicScheduler node"""
-    result = {
-        "scheduler": inputs.get("scheduler", ""),
-        "denoise": str(inputs.get("denoise", "1.0"))
-    }
-    
-    # Get steps from inputs or steps input
-    if "steps" in inputs:
-        if isinstance(inputs["steps"], str):
-            result["steps"] = inputs["steps"]
-        elif isinstance(inputs["steps"], dict) and "value" in inputs["steps"]:
-            result["steps"] = str(inputs["steps"]["value"])
-        else:
-            result["steps"] = str(inputs["steps"])
-    
-    return result
-
-def transform_basic_guider(inputs: Dict) -> Dict:
-    """Transform function for BasicGuider node"""
-    result = {}
-    
-    # Process conditioning
-    if "conditioning" in inputs:
-        if isinstance(inputs["conditioning"], str):
-            result["prompt"] = inputs["conditioning"]
-        elif isinstance(inputs["conditioning"], dict):
-            result["conditioning"] = inputs["conditioning"]
-    
-    # Get model information if needed
-    if "model" in inputs and isinstance(inputs["model"], dict):
-        result["model"] = inputs["model"]
-    
-    return result
-
-def transform_model_sampling_flux(inputs: Dict) -> Dict:
-    """Transform function for ModelSamplingFlux - mostly a pass-through node"""
-    # This node is primarily used for routing, so we mostly pass through values
-    
-    return inputs["model"]
-
-def transform_sampler_custom_advanced(inputs: Dict) -> Dict:
-    """Transform function for SamplerCustomAdvanced node"""
-    result = {}
-    
-    # Extract seed from noise
-    if "noise" in inputs and isinstance(inputs["noise"], dict):
-        result["seed"] = str(inputs["noise"].get("seed", ""))
-    
-    # Extract sampler info
-    if "sampler" in inputs and isinstance(inputs["sampler"], dict):
-        sampler = inputs["sampler"].get("sampler", "")
-        if sampler:
-            result["sampler"] = sampler
-    
-    # Extract scheduler, steps, denoise from sigmas
-    if "sigmas" in inputs and isinstance(inputs["sigmas"], dict):
-        sigmas = inputs["sigmas"]
-        result["scheduler"] = sigmas.get("scheduler", "")
-        result["steps"] = str(sigmas.get("steps", ""))
-        result["denoise"] = str(sigmas.get("denoise", "1.0"))
-    
-    # Extract prompt and guidance from guider
-    if "guider" in inputs and isinstance(inputs["guider"], dict):
-        guider = inputs["guider"]
-        
-        # Get prompt from conditioning
-        if "conditioning" in guider and isinstance(guider["conditioning"], str):
-            result["prompt"] = guider["conditioning"]
-        elif "conditioning" in guider and isinstance(guider["conditioning"], dict):
-            result["guidance"] = guider["conditioning"].get("guidance", "")
-            result["prompt"] = guider["conditioning"].get("prompt", "")
-
-        if "model" in guider and isinstance(guider["model"], dict):
-            result["checkpoint"] = guider["model"].get("checkpoint", "")
-            result["loras"] = guider["model"].get("loras", "")
-            result["clip_skip"] = str(int(guider["model"].get("clip_skip", "-1")) * -1)
-    
-    # Extract dimensions from latent_image
-    if "latent_image" in inputs and isinstance(inputs["latent_image"], dict):
-        latent = inputs["latent_image"]
-        width = latent.get("width", 0)
-        height = latent.get("height", 0)
-        if width and height:
-            result["width"] = width
-            result["height"] = height
-            result["size"] = f"{width}x{height}"
-    
-    return result
-
-def transform_ksampler(inputs: Dict) -> Dict:
-    """Transform function for KSampler nodes"""
-    result = {
-        "seed": str(inputs.get("seed", "")),
-        "steps": str(inputs.get("steps", "")),
-        "cfg": str(inputs.get("cfg", "")),
-        "sampler": inputs.get("sampler_name", ""),
-        "scheduler": inputs.get("scheduler", ""),
-    }
-    
-    # Process positive prompt
-    if "positive" in inputs:
-        result["prompt"] = inputs["positive"]
-    
-    # Process negative prompt
-    if "negative" in inputs:
-        result["negative_prompt"] = inputs["negative"]
-    
-    # Get dimensions from latent image
-    if "latent_image" in inputs and isinstance(inputs["latent_image"], dict):
-        width = inputs["latent_image"].get("width", 0)
-        height = inputs["latent_image"].get("height", 0)
-        if width and height:
-            result["size"] = f"{width}x{height}"
-    
-    # Add clip_skip if present
-    if "clip_skip" in inputs:
-        result["clip_skip"] = str(inputs.get("clip_skip", ""))
-
-    # Add guidance if present
-    if "guidance" in inputs:
-        result["guidance"] = str(inputs.get("guidance", ""))
-
-    # Add model if present
-    if "model" in inputs:
-        result["checkpoint"] = inputs.get("model", {}).get("checkpoint", "")
-        result["loras"] = inputs.get("model", {}).get("loras", "")
-        result["clip_skip"] = str(inputs.get("model", {}).get("clip_skip", -1) * -1)
-        
-    return result
-
-def transform_empty_latent(inputs: Dict) -> Dict:
-    """Transform function for EmptyLatentImage nodes"""
-    width = inputs.get("width", 0)
-    height = inputs.get("height", 0)
-    return {"width": width, "height": height, "size": f"{width}x{height}"}
-
-def transform_clip_text(inputs: Dict) -> Any:
-    """Transform function for CLIPTextEncode nodes"""
-    return inputs.get("text", "")
-
-def transform_flux_guidance(inputs: Dict) -> Dict:
-    """Transform function for FluxGuidance nodes"""
-    result = {}
-    
-    if "guidance" in inputs:
-        result["guidance"] = inputs["guidance"]
-    
-    if "conditioning" in inputs:
-        conditioning = inputs["conditioning"]
-        if isinstance(conditioning, str):
-            result["prompt"] = conditioning
-        else:
-            result["prompt"] = "Unknown prompt"
-    
-    return result
-
-def transform_unet_loader(inputs: Dict) -> Dict:
-    """Transform function for UNETLoader node"""
-    unet_name = inputs.get("unet_name", "")
-    return {"checkpoint": unet_name} if unet_name else {}
-
-def transform_checkpoint_loader(inputs: Dict) -> Dict:
-    """Transform function for CheckpointLoaderSimple node"""
-    ckpt_name = inputs.get("ckpt_name", "")
-    return {"checkpoint": ckpt_name} if ckpt_name else {}
-
-def transform_latent_upscale_by(inputs: Dict) -> Dict:
-    """Transform function for LatentUpscaleBy node"""
-    result = {}
-    
-    width = inputs["samples"].get("width", 0) * inputs["scale_by"]
-    height = inputs["samples"].get("height", 0) * inputs["scale_by"]
-    result["width"] = width
-    result["height"] = height
-    result["size"] = f"{width}x{height}"
-    
-    return result
-
-def transform_clip_set_last_layer(inputs: Dict) -> Dict:
-    """Transform function for CLIPSetLastLayer node"""
-    result = {}
-    
-    if "stop_at_clip_layer" in inputs:
-        result["clip_skip"] = inputs["stop_at_clip_layer"]
-    
-    return result
-
-# =============================================================================
-# Node Mapper Definitions
-# =============================================================================
-
-# Define the mappers for ComfyUI core nodes not in main mapper
-NODE_MAPPERS_EXT = {
-    # KSamplers
-    "SamplerCustomAdvanced": {
-        "inputs_to_track": ["noise", "guider", "sampler", "sigmas", "latent_image"],
-        "transform_func": transform_sampler_custom_advanced
-    },
-    "KSampler": {
-        "inputs_to_track": [
-            "seed", "steps", "cfg", "sampler_name", "scheduler", 
-            "denoise", "positive", "negative", "latent_image",
-            "model", "clip_skip"
-        ],
-        "transform_func": transform_ksampler
-    },
-    # ComfyUI core nodes
-    "EmptyLatentImage": {
-        "inputs_to_track": ["width", "height", "batch_size"],
-        "transform_func": transform_empty_latent
-    },
-    "EmptySD3LatentImage": {
-        "inputs_to_track": ["width", "height", "batch_size"],
-        "transform_func": transform_empty_latent
-    },
-    "CLIPTextEncode": {
-        "inputs_to_track": ["text", "clip"],
-        "transform_func": transform_clip_text
-    },
-    "FluxGuidance": {
-        "inputs_to_track": ["guidance", "conditioning"],
-        "transform_func": transform_flux_guidance
-    },
-    "RandomNoise": {
-        "inputs_to_track": ["noise_seed"],
-        "transform_func": transform_random_noise
-    },
-    "KSamplerSelect": {
-        "inputs_to_track": ["sampler_name"],
-        "transform_func": transform_ksampler_select
-    },
-    "BasicScheduler": {
-        "inputs_to_track": ["scheduler", "steps", "denoise", "model"],
-        "transform_func": transform_basic_scheduler
-    },
-    "BasicGuider": {
-        "inputs_to_track": ["model", "conditioning"],
-        "transform_func": transform_basic_guider
-    },
-    "ModelSamplingFlux": {
-        "inputs_to_track": ["max_shift", "base_shift", "width", "height", "model"],
-        "transform_func": transform_model_sampling_flux
-    },
-    "UNETLoader": {
-        "inputs_to_track": ["unet_name"],
-        "transform_func": transform_unet_loader
-    },
-    "CheckpointLoaderSimple": {
-        "inputs_to_track": ["ckpt_name"],
-        "transform_func": transform_checkpoint_loader
-    },
-    "LatentUpscale": {
-        "inputs_to_track": ["width", "height"],
-        "transform_func": transform_empty_latent
-    },
-    "LatentUpscaleBy": {
-        "inputs_to_track": ["samples", "scale_by"],
-        "transform_func": transform_latent_upscale_by
-    },
-    "CLIPSetLastLayer": {
-        "inputs_to_track": ["clip", "stop_at_clip_layer"],
-        "transform_func": transform_clip_set_last_layer
-    }
-} 

py/workflow/ext/kjnodes.py

@@ -1,74 +0,0 @@
-"""
-KJNodes mappers extension for ComfyUI workflow parsing
-"""
-import logging
-import re
-from typing import Dict, Any
-
-logger = logging.getLogger(__name__)
-
-# =============================================================================
-# Transform Functions
-# =============================================================================
-
-def transform_join_strings(inputs: Dict) -> str:
-    """Transform function for JoinStrings nodes"""
-    string1 = inputs.get("string1", "")
-    string2 = inputs.get("string2", "")
-    delimiter = inputs.get("delimiter", "")
-    return f"{string1}{delimiter}{string2}"
-
-def transform_string_constant(inputs: Dict) -> str:
-    """Transform function for StringConstant nodes"""
-    return inputs.get("string", "")
-
-def transform_empty_latent_presets(inputs: Dict) -> Dict:
-    """Transform function for EmptyLatentImagePresets nodes"""
-    dimensions = inputs.get("dimensions", "")
-    invert = inputs.get("invert", False)
-    
-    # Extract width and height from dimensions string
-    # Expected format: "width x height (ratio)" or similar
-    width = 0
-    height = 0
-    
-    if dimensions:
-        # Try to extract dimensions using regex
-        match = re.search(r'(\d+)\s*x\s*(\d+)', dimensions)
-        if match:
-            width = int(match.group(1))
-            height = int(match.group(2))
-    
-    # If invert is True, swap width and height
-    if invert and width and height:
-        width, height = height, width
-    
-    return {"width": width, "height": height, "size": f"{width}x{height}"}
-
-def transform_int_constant(inputs: Dict) -> int:
-    """Transform function for INTConstant nodes"""
-    return inputs.get("value", 0)
-
-# =============================================================================
-# Node Mapper Definitions
-# =============================================================================
-
-# Define the mappers for KJNodes
-NODE_MAPPERS_EXT = {
-    "JoinStrings": {
-        "inputs_to_track": ["string1", "string2", "delimiter"],
-        "transform_func": transform_join_strings
-    },
-    "StringConstantMultiline": {
-        "inputs_to_track": ["string"],
-        "transform_func": transform_string_constant
-    },
-    "EmptyLatentImagePresets": {
-        "inputs_to_track": ["dimensions", "invert", "batch_size"],
-        "transform_func": transform_empty_latent_presets
-    },
-    "INTConstant": {
-        "inputs_to_track": ["value"],
-        "transform_func": transform_int_constant
-    }
-} 

py/workflow/main.py

@@ -1,37 +0,0 @@
-"""
-Main entry point for the workflow parser module
-"""
-import os
-import sys
-import logging
-from typing import Dict, Optional, Union
-
-# Add the parent directory to sys.path to enable imports
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-ROOT_DIR = os.path.abspath(os.path.join(SCRIPT_DIR, '..', '..'))
-sys.path.insert(0, os.path.dirname(SCRIPT_DIR))
-
-from .parser import parse_workflow
-
-logger = logging.getLogger(__name__)
-
-def parse_comfyui_workflow(
-    workflow_path: str, 
-    output_path: Optional[str] = None
-) -> Dict:
-    """
-    Parse a ComfyUI workflow file and extract generation parameters
-    
-    Args:
-        workflow_path: Path to the workflow JSON file
-        output_path: Optional path to save the output JSON
-        
-    Returns:
-        Dictionary containing extracted parameters
-    """
-    return parse_workflow(workflow_path, output_path)
-
-if __name__ == "__main__":
-    # If run directly, use the CLI
-    from .cli import main
-    main() 

py/workflow/mappers.py

@@ -1,282 +0,0 @@
-"""
-Node mappers for ComfyUI workflow parsing
-"""
-import logging
-import os
-import importlib.util
-import inspect
-from typing import Dict, List, Any, Optional, Union, Type, Callable, Tuple
-
-logger = logging.getLogger(__name__)
-
-# Global mapper registry
-_MAPPER_REGISTRY: Dict[str, Dict] = {}
-
-# =============================================================================
-# Mapper Definition Functions
-# =============================================================================
-
-def create_mapper(
-    node_type: str,
-    inputs_to_track: List[str],
-    transform_func: Callable[[Dict], Any] = None
-) -> Dict:
-    """Create a mapper definition for a node type"""
-    mapper = {
-        "node_type": node_type,
-        "inputs_to_track": inputs_to_track,
-        "transform": transform_func or (lambda inputs: inputs)
-    }
-    return mapper
-
-def register_mapper(mapper: Dict) -> None:
-    """Register a node mapper in the global registry"""
-    _MAPPER_REGISTRY[mapper["node_type"]] = mapper
-    logger.debug(f"Registered mapper for node type: {mapper['node_type']}")
-
-def get_mapper(node_type: str) -> Optional[Dict]:
-    """Get a mapper for the specified node type"""
-    return _MAPPER_REGISTRY.get(node_type)
-
-def get_all_mappers() -> Dict[str, Dict]:
-    """Get all registered mappers"""
-    return _MAPPER_REGISTRY.copy()
-
-# =============================================================================
-# Node Processing Function
-# =============================================================================
-
-def process_node(node_id: str, node_data: Dict, workflow: Dict, parser: 'WorkflowParser') -> Any: # type: ignore
-    """Process a node using its mapper and extract relevant information"""
-    node_type = node_data.get("class_type")
-    mapper = get_mapper(node_type)
-    
-    if not mapper:
-        logger.warning(f"No mapper found for node type: {node_type}")
-        return None
-        
-    result = {}
-    
-    # Extract inputs based on the mapper's tracked inputs
-    for input_name in mapper["inputs_to_track"]:
-        if input_name in node_data.get("inputs", {}):
-            input_value = node_data["inputs"][input_name]
-            
-            # Check if input is a reference to another node's output
-            if isinstance(input_value, list) and len(input_value) == 2:
-                try:
-                    # Format is [node_id, output_slot]
-                    ref_node_id, output_slot = input_value
-                    # Convert node_id to string if it's an integer
-                    if isinstance(ref_node_id, int):
-                        ref_node_id = str(ref_node_id)
-                    
-                    # Recursively process the referenced node
-                    ref_value = parser.process_node(ref_node_id, workflow)
-                    
-                    if ref_value is not None:
-                        result[input_name] = ref_value
-                    else:
-                        # If we couldn't get a value from the reference, store the raw value
-                        result[input_name] = input_value
-                except Exception as e:
-                    logger.error(f"Error processing reference in node {node_id}, input {input_name}: {e}")
-                    result[input_name] = input_value
-            else:
-                # Direct value
-                result[input_name] = input_value
-    
-    # Apply the transform function
-    try:
-        return mapper["transform"](result)
-    except Exception as e:
-        logger.error(f"Error in transform function for node {node_id} of type {node_type}: {e}")
-        return result
-
-# =============================================================================
-# Transform Functions
-# =============================================================================
-
-
-
-def transform_lora_loader(inputs: Dict) -> Dict:
-    """Transform function for LoraLoader nodes"""
-    loras_data = inputs.get("loras", [])
-    lora_stack = inputs.get("lora_stack", {}).get("lora_stack", [])
-    
-    lora_texts = []
-    
-    # Process loras array
-    if isinstance(loras_data, dict) and "__value__" in loras_data:
-        loras_list = loras_data["__value__"]
-    elif isinstance(loras_data, list):
-        loras_list = loras_data
-    else:
-        loras_list = []
-        
-    # Process each active lora entry
-    for lora in loras_list:
-        if isinstance(lora, dict) and lora.get("active", False):
-            lora_name = lora.get("name", "")
-            strength = lora.get("strength", 1.0)
-            lora_texts.append(f"<lora:{lora_name}:{strength}>")
-    
-    # Process lora_stack if valid
-    if lora_stack and isinstance(lora_stack, list):
-        if not (len(lora_stack) == 2 and isinstance(lora_stack[0], (str, int)) and isinstance(lora_stack[1], int)):
-            for stack_entry in lora_stack:
-                lora_name = stack_entry[0]
-                strength = stack_entry[1]
-                lora_texts.append(f"<lora:{lora_name}:{strength}>")
-
-    result = {
-        "checkpoint": inputs.get("model", {}).get("checkpoint", ""),
-        "loras": " ".join(lora_texts)
-    }
-
-    if "clip" in inputs and isinstance(inputs["clip"], dict):
-        result["clip_skip"] = inputs["clip"].get("clip_skip", "-1")
-    
-    return result
-
-def transform_lora_stacker(inputs: Dict) -> Dict:
-    """Transform function for LoraStacker nodes"""
-    loras_data = inputs.get("loras", [])
-    result_stack = []
-    
-    # Handle existing stack entries
-    existing_stack = []
-    lora_stack_input = inputs.get("lora_stack", [])
-    
-    if isinstance(lora_stack_input, dict) and "lora_stack" in lora_stack_input:
-        existing_stack = lora_stack_input["lora_stack"]
-    elif isinstance(lora_stack_input, list):
-        if not (len(lora_stack_input) == 2 and isinstance(lora_stack_input[0], (str, int)) and 
-               isinstance(lora_stack_input[1], int)):
-            existing_stack = lora_stack_input
-    
-    # Add existing entries
-    if existing_stack:
-        result_stack.extend(existing_stack)
-    
-    # Process new loras
-    if isinstance(loras_data, dict) and "__value__" in loras_data:
-        loras_list = loras_data["__value__"]
-    elif isinstance(loras_data, list):
-        loras_list = loras_data
-    else:
-        loras_list = []
-        
-    for lora in loras_list:
-        if isinstance(lora, dict) and lora.get("active", False):
-            lora_name = lora.get("name", "")
-            strength = float(lora.get("strength", 1.0))
-            result_stack.append((lora_name, strength))
-    
-    return {"lora_stack": result_stack}
-
-def transform_trigger_word_toggle(inputs: Dict) -> str:
-    """Transform function for TriggerWordToggle nodes"""
-    toggle_data = inputs.get("toggle_trigger_words", [])
-
-    if isinstance(toggle_data, dict) and "__value__" in toggle_data:
-        toggle_words = toggle_data["__value__"]
-    elif isinstance(toggle_data, list):
-        toggle_words = toggle_data
-    else:
-        toggle_words = []
-    
-    # Filter active trigger words
-    active_words = []
-    for item in toggle_words:
-        if isinstance(item, dict) and item.get("active", False):
-            word = item.get("text", "")
-            if word and not word.startswith("__dummy"):
-                active_words.append(word)
-    
-    return ", ".join(active_words)
-
-# =============================================================================
-# Node Mapper Definitions
-# =============================================================================
-
-# Central definition of all supported node types and their configurations
-NODE_MAPPERS = {
-    
-    # LoraManager nodes
-    "Lora Loader (LoraManager)": {
-        "inputs_to_track": ["model", "clip", "loras", "lora_stack"],
-        "transform_func": transform_lora_loader
-    },
-    "Lora Stacker (LoraManager)": {
-        "inputs_to_track": ["loras", "lora_stack"],
-        "transform_func": transform_lora_stacker
-    },
-    "TriggerWord Toggle (LoraManager)": {
-        "inputs_to_track": ["toggle_trigger_words"],
-        "transform_func": transform_trigger_word_toggle
-    }   
-}
-
-def register_all_mappers() -> None:
-    """Register all mappers from the NODE_MAPPERS dictionary"""
-    for node_type, config in NODE_MAPPERS.items():
-        mapper = create_mapper(
-            node_type=node_type,
-            inputs_to_track=config["inputs_to_track"],
-            transform_func=config["transform_func"]
-        )
-        register_mapper(mapper)
-    logger.info(f"Registered {len(NODE_MAPPERS)} node mappers")
-
-# =============================================================================
-# Extension Loading
-# =============================================================================
-
-def load_extensions(ext_dir: str = None) -> None:
-    """
-    Load mapper extensions from the specified directory
-    
-    Extension files should define a NODE_MAPPERS_EXT dictionary containing mapper configurations.
-    These will be added to the global NODE_MAPPERS dictionary and registered automatically.
-    """
-    # Use default path if none provided
-    if ext_dir is None:
-        # Get the directory of this file
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        ext_dir = os.path.join(current_dir, 'ext')
-    
-    # Ensure the extension directory exists
-    if not os.path.exists(ext_dir):
-        os.makedirs(ext_dir, exist_ok=True)
-        logger.info(f"Created extension directory: {ext_dir}")
-        return
-    
-    # Load each Python file in the extension directory
-    for filename in os.listdir(ext_dir):
-        if filename.endswith('.py') and not filename.startswith('_'):
-            module_path = os.path.join(ext_dir, filename)
-            module_name = f"workflow.ext.{filename[:-3]}"  # Remove .py
-            
-            try:
-                # Load the module
-                spec = importlib.util.spec_from_file_location(module_name, module_path)
-                if spec and spec.loader:
-                    module = importlib.util.module_from_spec(spec)
-                    spec.loader.exec_module(module)
-                    
-                    # Check if the module defines NODE_MAPPERS_EXT
-                    if hasattr(module, 'NODE_MAPPERS_EXT'):
-                        # Add the extension mappers to the global NODE_MAPPERS dictionary
-                        NODE_MAPPERS.update(module.NODE_MAPPERS_EXT)
-                        logger.info(f"Added {len(module.NODE_MAPPERS_EXT)} mappers from extension: {filename}")
-                    else:
-                        logger.warning(f"Extension {filename} does not define NODE_MAPPERS_EXT dictionary")
-            except Exception as e:
-                logger.warning(f"Error loading extension {filename}: {e}")
-    
-    # Re-register all mappers after loading extensions
-    register_all_mappers()
-
-# Initialize the registry with default mappers
-# register_default_mappers() 

py/workflow/parser.py

@@ -1,181 +0,0 @@
-"""
-Main workflow parser implementation for ComfyUI
-"""
-import json
-import logging
-from typing import Dict, List, Any, Optional, Union, Set
-from .mappers import get_mapper, get_all_mappers, load_extensions, process_node
-from .utils import (
-    load_workflow, save_output, find_node_by_type,
-    trace_model_path
-)
-
-logger = logging.getLogger(__name__)
-
-class WorkflowParser:
-    """Parser for ComfyUI workflows"""
-    
-    def __init__(self):
-        """Initialize the parser with mappers"""
-        self.processed_nodes: Set[str] = set()  # Track processed nodes to avoid cycles
-        self.node_results_cache: Dict[str, Any] = {}  # Cache for processed node results
-        
-        # Load extensions
-        load_extensions()
-    
-    def process_node(self, node_id: str, workflow: Dict) -> Any:
-        """Process a single node and extract relevant information"""
-        # Return cached result if available
-        if node_id in self.node_results_cache:
-            return self.node_results_cache[node_id]
-            
-        # Check if we're in a cycle
-        if node_id in self.processed_nodes:
-            return None
-        
-        # Mark this node as being processed (to detect cycles)
-        self.processed_nodes.add(node_id)
-        
-        if node_id not in workflow:
-            self.processed_nodes.remove(node_id)
-            return None
-        
-        node_data = workflow[node_id]
-        node_type = node_data.get("class_type")
-        
-        result = None
-        if get_mapper(node_type):
-            try:
-                result = process_node(node_id, node_data, workflow, self)
-                # Cache the result
-                self.node_results_cache[node_id] = result
-            except Exception as e:
-                logger.error(f"Error processing node {node_id} of type {node_type}: {e}", exc_info=True)
-                # Return a partial result or None depending on how we want to handle errors
-                result = {}
-        
-        # Remove node from processed set to allow it to be processed again in a different context
-        self.processed_nodes.remove(node_id)
-        return result
-    
-    def find_primary_sampler_node(self, workflow: Dict) -> Optional[str]:
-        """
-        Find the primary sampler node in the workflow.
-        
-        Priority:
-        1. First try to find a SamplerCustomAdvanced node
-        2. If not found, look for KSampler nodes with denoise=1.0
-        3. If still not found, use the first KSampler node
-        
-        Args:
-            workflow: The workflow data as a dictionary
-            
-        Returns:
-            The node ID of the primary sampler node, or None if not found
-        """
-        # First check for SamplerCustomAdvanced nodes
-        sampler_advanced_nodes = []
-        ksampler_nodes = []
-        
-        # Scan workflow for sampler nodes
-        for node_id, node_data in workflow.items():
-            node_type = node_data.get("class_type")
-            
-            if node_type == "SamplerCustomAdvanced":
-                sampler_advanced_nodes.append(node_id)
-            elif node_type == "KSampler":
-                ksampler_nodes.append(node_id)
-        
-        # If we found SamplerCustomAdvanced nodes, return the first one
-        if sampler_advanced_nodes:
-            logger.debug(f"Found SamplerCustomAdvanced node: {sampler_advanced_nodes[0]}")
-            return sampler_advanced_nodes[0]
-        
-        # If we have KSampler nodes, look for one with denoise=1.0
-        if ksampler_nodes:
-            for node_id in ksampler_nodes:
-                node_data = workflow[node_id]
-                inputs = node_data.get("inputs", {})
-                denoise = inputs.get("denoise", 0)
-                
-                # Check if denoise is 1.0 (allowing for small floating point differences)
-                if abs(float(denoise) - 1.0) < 0.001:
-                    logger.debug(f"Found KSampler node with denoise=1.0: {node_id}")
-                    return node_id
-            
-            # If no KSampler with denoise=1.0 found, use the first one
-            logger.debug(f"No KSampler with denoise=1.0 found, using first KSampler: {ksampler_nodes[0]}")
-            return ksampler_nodes[0]
-        
-        # No sampler nodes found
-        logger.warning("No sampler nodes found in workflow")
-        return None
-    
-    def parse_workflow(self, workflow_data: Union[str, Dict], output_path: Optional[str] = None) -> Dict:
-        """
-        Parse the workflow and extract generation parameters
-        
-        Args:
-            workflow_data: The workflow data as a dictionary or a file path
-            output_path: Optional path to save the output JSON
-            
-        Returns:
-            Dictionary containing extracted parameters
-        """
-        # Load workflow from file if needed
-        if isinstance(workflow_data, str):
-            workflow = load_workflow(workflow_data)
-        else:
-            workflow = workflow_data
-            
-        # Reset the processed nodes tracker and cache
-        self.processed_nodes = set()
-        self.node_results_cache = {}
-        
-        # Find the primary sampler node
-        sampler_node_id = self.find_primary_sampler_node(workflow)
-        if not sampler_node_id:
-            logger.warning("No suitable sampler node found in workflow")
-            return {}
-        
-        # Process sampler node to extract parameters
-        sampler_result = self.process_node(sampler_node_id, workflow)
-        if not sampler_result:
-            return {}
-        
-        # Return the sampler result directly - it's already in the format we need
-        # This simplifies the structure and makes it easier to use in recipe_routes.py
-        
-        # Handle standard ComfyUI names vs our output format
-        if "cfg" in sampler_result:
-            sampler_result["cfg_scale"] = sampler_result.pop("cfg")
-            
-        # Add clip_skip = 1 to match reference output if not already present
-        if "clip_skip" not in sampler_result:
-            sampler_result["clip_skip"] = "1"
-        
-        # Ensure the prompt is a string and not a nested dictionary
-        if "prompt" in sampler_result and isinstance(sampler_result["prompt"], dict):
-            if "prompt" in sampler_result["prompt"]:
-                sampler_result["prompt"] = sampler_result["prompt"]["prompt"]
-        
-        # Save the result if requested
-        if output_path:
-            save_output(sampler_result, output_path)
-            
-        return sampler_result
-
-
-def parse_workflow(workflow_path: str, output_path: Optional[str] = None) -> Dict:
-    """
-    Parse a ComfyUI workflow file and extract generation parameters
-    
-    Args:
-        workflow_path: Path to the workflow JSON file
-        output_path: Optional path to save the output JSON
-        
-    Returns:
-        Dictionary containing extracted parameters
-    """
-    parser = WorkflowParser()
-    return parser.parse_workflow(workflow_path, output_path)

py/workflow/test.py

@@ -1,63 +0,0 @@
-"""
-Test script for the ComfyUI workflow parser
-"""
-import os
-import json
-import logging
-from .parser import parse_workflow
-
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler()]
-)
-logger = logging.getLogger(__name__)
-
-# Configure paths
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-ROOT_DIR = os.path.abspath(os.path.join(SCRIPT_DIR, '..', '..'))
-REFS_DIR = os.path.join(ROOT_DIR, 'refs')
-OUTPUT_DIR = os.path.join(ROOT_DIR, 'output')
-
-def test_parse_flux_workflow():
-    """Test parsing the flux example workflow"""
-    # Ensure output directory exists
-    os.makedirs(OUTPUT_DIR, exist_ok=True)
-    
-    # Define input and output paths
-    input_path = os.path.join(REFS_DIR, 'flux_prompt.json')
-    output_path = os.path.join(OUTPUT_DIR, 'parsed_flux_output.json')
-    
-    # Parse workflow
-    logger.info(f"Parsing workflow: {input_path}")
-    result = parse_workflow(input_path, output_path)
-    
-    # Print result summary
-    logger.info(f"Output saved to: {output_path}")
-    logger.info(f"Parsing completed. Result summary:")
-    logger.info(f"  LoRAs: {result.get('loras', '')}")
-    
-    gen_params = result.get('gen_params', {})
-    logger.info(f"  Prompt: {gen_params.get('prompt', '')[:50]}...")
-    logger.info(f"  Steps: {gen_params.get('steps', '')}")
-    logger.info(f"  Sampler: {gen_params.get('sampler', '')}")
-    logger.info(f"  Size: {gen_params.get('size', '')}")
-    
-    # Compare with reference output
-    ref_output_path = os.path.join(REFS_DIR, 'flux_output.json')
-    try:
-        with open(ref_output_path, 'r') as f:
-            ref_output = json.load(f)
-            
-        # Simple validation
-        loras_match = result.get('loras', '') == ref_output.get('loras', '')
-        prompt_match = gen_params.get('prompt', '') == ref_output.get('gen_params', {}).get('prompt', '')
-        
-        logger.info(f"Validation against reference:")
-        logger.info(f"  LoRAs match: {loras_match}")
-        logger.info(f"  Prompt match: {prompt_match}")
-    except Exception as e:
-        logger.warning(f"Failed to compare with reference output: {e}")
-
-if __name__ == "__main__":
-    test_parse_flux_workflow() 

py/workflow/utils.py

@@ -1,120 +0,0 @@
-"""
-Utility functions for ComfyUI workflow parsing
-"""
-import json
-import os
-import logging
-from typing import Dict, List, Any, Optional, Union, Set, Tuple
-
-logger = logging.getLogger(__name__)
-
-def load_workflow(workflow_path: str) -> Dict:
-    """Load a workflow from a JSON file"""
-    try:
-        with open(workflow_path, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    except Exception as e:
-        logger.error(f"Error loading workflow from {workflow_path}: {e}")
-        raise
-
-def save_output(output: Dict, output_path: str) -> None:
-    """Save the parsed output to a JSON file"""
-    os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
-    try:
-        with open(output_path, 'w', encoding='utf-8') as f:
-            json.dump(output, f, indent=4)
-    except Exception as e:
-        logger.error(f"Error saving output to {output_path}: {e}")
-        raise
-
-def find_node_by_type(workflow: Dict, node_type: str) -> Optional[str]:
-    """Find a node of the specified type in the workflow"""
-    for node_id, node_data in workflow.items():
-        if node_data.get("class_type") == node_type:
-            return node_id
-    return None
-
-def find_nodes_by_type(workflow: Dict, node_type: str) -> List[str]:
-    """Find all nodes of the specified type in the workflow"""
-    return [node_id for node_id, node_data in workflow.items() 
-            if node_data.get("class_type") == node_type]
-
-def get_input_node_ids(workflow: Dict, node_id: str) -> Dict[str, Tuple[str, int]]:
-    """
-    Get the node IDs for all inputs of the given node
-    
-    Returns a dictionary mapping input names to (node_id, output_slot) tuples
-    """
-    result = {}
-    if node_id not in workflow:
-        return result
-        
-    node_data = workflow[node_id]
-    for input_name, input_value in node_data.get("inputs", {}).items():
-        # Check if this input is connected to another node
-        if isinstance(input_value, list) and len(input_value) == 2:
-            # Input is connected to another node's output
-            # Format: [node_id, output_slot]
-            ref_node_id, output_slot = input_value
-            result[input_name] = (str(ref_node_id), output_slot)
-            
-    return result
-
-def trace_model_path(workflow: Dict, start_node_id: str) -> List[str]:
-    """
-    Trace the model path backward from KSampler to find all LoRA nodes
-    
-    Args:
-        workflow: The workflow data
-        start_node_id: The starting node ID (usually KSampler)
-        
-    Returns:
-        List of node IDs in the model path
-    """
-    model_path_nodes = []
-    
-    # Get the model input from the start node
-    if start_node_id not in workflow:
-        return model_path_nodes
-    
-    # Track visited nodes to avoid cycles
-    visited = set()
-    
-    # Stack for depth-first search
-    stack = []
-    
-    # Get model input reference if available
-    start_node = workflow[start_node_id]
-    if "inputs" in start_node and "model" in start_node["inputs"] and isinstance(start_node["inputs"]["model"], list):
-        model_ref = start_node["inputs"]["model"]
-        stack.append(str(model_ref[0]))
-    
-    # Perform depth-first search
-    while stack:
-        node_id = stack.pop()
-        
-        # Skip if already visited
-        if node_id in visited:
-            continue
-        
-        # Mark as visited
-        visited.add(node_id)
-        
-        # Skip if node doesn't exist
-        if node_id not in workflow:
-            continue
-        
-        node = workflow[node_id]
-        node_type = node.get("class_type", "")
-        
-        # Add current node to result list if it's a LoRA node
-        if "Lora" in node_type:
-            model_path_nodes.append(node_id)
-        
-        # Add all input nodes that have a "model" or "lora_stack" output to the stack
-        if "inputs" in node:
-            for input_name, input_value in node["inputs"].items():
-                if input_name in ["model", "lora_stack"] and isinstance(input_value, list) and len(input_value) == 2:
-                    stack.append(str(input_value[0]))
-    
-    return model_path_nodes 

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-lora-manager"
 description = "LoRA Manager for ComfyUI - Access it at http://localhost:8188/loras for managing LoRA models with previews and metadata integration."
-version = "0.8.11"
+version = "0.8.14"
 license = {file = "LICENSE"}
 dependencies = [
     "aiohttp",
@@ -13,7 +13,8 @@ dependencies = [
     "Pillow",
     "olefile", # for getting rid of warning message
     "requests",
-    "toml"
+    "toml",
+    "natsort"
 ]
 
 [project.urls]

requirements.txt

@@ -9,4 +9,5 @@ olefile
 requests
 toml
 numpy
-torch
+torch
+natsort

static/css/base.css

@@ -38,7 +38,7 @@ html, body {
     --lora-border: oklch(90% 0.02 256 / 0.15);
     --lora-text: oklch(95% 0.02 256);
     --lora-error: oklch(75% 0.32 29);
-    --lora-warning: oklch(75% 0.25 80); /* Add warning color for deleted LoRAs */
+    --lora-warning: oklch(75% 0.25 80); /* Modified to be used with oklch() */
     
     /* Spacing Scale */
     --space-1: calc(8px * 1);
@@ -79,7 +79,7 @@ html[data-theme="light"] {
     --lora-surface: oklch(25% 0.02 256 / 0.98);
     --lora-border: oklch(90% 0.02 256 / 0.15);
     --lora-text: oklch(98% 0.02 256);
-    --lora-warning: oklch(75% 0.25 80); /* Add warning color for dark theme too */
+    --lora-warning: oklch(75% 0.25 80); /* Modified to be used with oklch() */
 }
 
 body {

static/css/components/alphabet-bar.css

@@ -0,0 +1,165 @@
+/* Alphabet Bar Component */
+.alphabet-bar-container {
+    position: fixed;
+    left: 0;
+    top: 50%;
+    transform: translateY(-50%);
+    z-index: 100;
+    display: flex;
+    transition: transform 0.3s ease;
+}
+
+.alphabet-bar-container.collapsed {
+    transform: translateY(-50%) translateX(-90%);
+}
+
+/* New visual indicator for when a letter is active and bar is collapsed */
+.alphabet-bar-container.collapsed .toggle-alphabet-bar.has-active-letter {
+    border-color: var(--lora-accent);
+    background: oklch(var(--lora-accent) / 0.15);
+}
+
+.alphabet-bar-container.collapsed .toggle-alphabet-bar.has-active-letter::after {
+    content: '';
+    position: absolute;
+    top: 7px;
+    right: 7px;
+    width: 8px;
+    height: 8px;
+    background-color: var(--lora-accent);
+    border-radius: 50%;
+    animation: pulse-active 2s infinite;
+}
+
+@keyframes pulse-active {
+    0% { transform: scale(0.8); opacity: 0.7; }
+    50% { transform: scale(1.1); opacity: 1; }
+    100% { transform: scale(0.8); opacity: 0.7; }
+}
+
+.alphabet-bar {
+    background: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-radius: 0 var(--border-radius-xs) var(--border-radius-xs) 0;
+    padding: 8px 4px;
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    align-items: center;
+    box-shadow: 2px 0 8px rgba(0, 0, 0, 0.1);
+    max-height: 80vh;
+    overflow-y: auto;
+    scrollbar-width: thin;
+}
+
+.alphabet-bar::-webkit-scrollbar {
+    width: 4px;
+}
+
+.alphabet-bar::-webkit-scrollbar-thumb {
+    background: var(--border-color);
+    border-radius: 4px;
+}
+
+.toggle-alphabet-bar {
+    background: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-left: none;
+    border-radius: 0 var(--border-radius-xs) var(--border-radius-xs) 0;
+    padding: 8px 4px;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--text-color);
+    width: 20px;
+    height: 40px;
+    align-self: center;
+    box-shadow: 2px 0 8px rgba(0, 0, 0, 0.1);
+}
+
+.toggle-alphabet-bar:hover {
+    background: var(--bg-hover);
+}
+
+.toggle-alphabet-bar i {
+    transition: transform 0.3s ease;
+}
+
+.alphabet-bar-container.collapsed .toggle-alphabet-bar i {
+    transform: rotate(180deg);
+}
+
+.letter-chip {
+    padding: 4px 2px;
+    border-radius: var(--border-radius-xs);
+    background: var(--bg-color);
+    color: var(--text-color);
+    cursor: pointer;
+    min-width: 24px;
+    text-align: center;
+    font-size: 0.85em;
+    transition: all 0.2s ease;
+    border: 1px solid var(--border-color);
+}
+
+.letter-chip:hover {
+    background: var(--lora-accent);
+    color: white;
+    transform: scale(1.1);
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.letter-chip.active {
+    background: var(--lora-accent);
+    color: white;
+    border-color: var(--lora-accent);
+}
+
+.letter-chip.disabled {
+    opacity: 0.5;
+    pointer-events: none;
+    cursor: default;
+}
+
+/* Hide the count by default, only show in tooltip */
+.letter-chip .count {
+    display: none;
+}
+
+.alphabet-bar-title {
+    font-size: 0.75em;
+    color: var(--text-color);
+    opacity: 0.7;
+    margin-bottom: 6px;
+    writing-mode: vertical-lr;
+    transform: rotate(180deg);
+    white-space: nowrap;
+}
+
+@media (max-width: 768px) {
+    .alphabet-bar-container {
+        transform: translateY(-50%) translateX(-90%);
+    }
+    
+    .alphabet-bar-container.active {
+        transform: translateY(-50%) translateX(0);
+    }
+    
+    .letter-chip {
+        padding: 3px 1px;
+        min-width: 20px;
+        font-size: 0.75em;
+    }
+}
+
+/* Keyframe animations for the active letter */
+@keyframes pulse {
+    0% { transform: scale(1); }
+    50% { transform: scale(1.1); }
+    100% { transform: scale(1); }
+}
+
+.letter-chip.active {
+    animation: pulse 1s ease-in-out 1;
+}

static/css/components/card.css

@@ -1,12 +1,13 @@
 /* 卡片网格布局 */
 .card-grid {
     display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(260px, 1fr)); /* Adjusted from 320px */
-    gap: 12px; /* Reduced from var(--space-2) for tighter horizontal spacing */
+    grid-template-columns: repeat(auto-fill, minmax(260px, 1fr)); /* Base size */
+    gap: 12px; /* Consistent gap for both row and column spacing */
+    row-gap: 20px; /* Increase vertical spacing between rows */
     margin-top: var(--space-2);
     padding-top: 4px; /* 添加顶部内边距，为悬停动画提供空间 */
     padding-bottom: 4px; /* 添加底部内边距，为悬停动画提供空间 */
-    max-width: 1400px; /* Container width control */
+    max-width: 1400px; /* Base container width */
     margin-left: auto;
     margin-right: auto;
 }
@@ -17,13 +18,14 @@
     border-radius: var(--border-radius-base);
     backdrop-filter: blur(16px);
     transition: transform 160ms ease-out;
-    aspect-ratio: 896/1152;
-    max-width: 260px; /* Adjusted from 320px to fit 5 cards */
+    aspect-ratio: 896/1152; /* Preserve aspect ratio */
+    max-width: 260px; /* Base size */
+    width: 100%;
     margin: 0 auto;
-    cursor: pointer; /* Added from recipe-card */
-    display: flex; /* Added from recipe-card */
-    flex-direction: column; /* Added from recipe-card */
-    overflow: hidden; /* Add overflow hidden to contain children */
+    cursor: pointer;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
 }
 
 .lora-card:hover {
@@ -36,6 +38,30 @@
     outline-offset: 2px;
 }
 
+/* Responsive adjustments for 1440p screens (2K) */
+@media (min-width: 2000px) {
+    .card-grid {
+        max-width: 1800px; /* Increased for 2K screens */
+        grid-template-columns: repeat(auto-fill, minmax(270px, 1fr));
+    }
+    
+    .lora-card {
+        max-width: 270px;
+    }
+}
+
+/* Responsive adjustments for 4K screens */
+@media (min-width: 3000px) {
+    .card-grid {
+        max-width: 2400px; /* Increased for 4K screens */
+        grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+    }
+    
+    .lora-card {
+        max-width: 280px;
+    }
+}
+
 /* Responsive adjustments */
 @media (max-width: 1400px) {
     .card-grid {
@@ -58,6 +84,26 @@
     min-height: 0; /* Fix for potential flexbox sizing issue in Firefox */
 }
 
+/* Smaller text for compact mode */
+.compact-mode .model-name {
+    font-size: 0.9em;
+    max-height: 2.4em;
+}
+
+.compact-mode .base-model-label {
+    font-size: 0.8em;
+    max-width: 110px;
+}
+
+.compact-mode .card-actions i {
+    font-size: 0.95em;
+    padding: 3px;
+}
+
+.compact-mode .model-info {
+    padding-bottom: 2px;
+}
+
 .card-preview img,
 .card-preview video {
     width: 100%;
@@ -362,4 +408,42 @@
     padding: 2rem;
     background: var(--lora-surface-alt);
     border-radius: var(--border-radius-base);
+}
+
+/* Virtual scrolling specific styles - updated */
+.virtual-scroll-item {
+    position: absolute;
+    box-sizing: border-box;
+    transition: transform 160ms ease-out;
+    margin: 0; /* Remove margins, positioning is handled by VirtualScroller */
+    width: 100%; /* Allow width to be set by the VirtualScroller */
+}
+
+.virtual-scroll-item:hover {
+    transform: translateY(-2px); /* Keep hover effect */
+    z-index: 1; /* Ensure hovered items appear above others */
+}
+
+/* When using virtual scroll, adjust container */
+.card-grid.virtual-scroll {
+    display: block;
+    position: relative;
+    margin: 0 auto;
+    padding: 6px 0; /* Add top/bottom padding equivalent to card padding */
+    height: auto;
+    width: 100%;
+    max-width: 1400px; /* Keep the max-width from original grid */
+}
+
+/* For larger screens, allow more space for the cards */
+@media (min-width: 2000px) {
+    .card-grid.virtual-scroll {
+        max-width: 1800px;
+    }
+}
+
+@media (min-width: 3000px) {
+    .card-grid.virtual-scroll {
+        max-width: 2400px;
+    }
 }

static/css/components/duplicates.css

@@ -0,0 +1,259 @@
+/* Duplicates Management Styles */
+
+/* Duplicates banner */
+.duplicates-banner {
+    position: sticky;
+    top: 48px; /* Match header height */
+    left: 0;
+    width: 100%;
+    background-color: var(--card-bg);
+    color: var(--text-color);
+    border-bottom: 1px solid var(--border-color);
+    z-index: var(--z-overlay);
+    padding: 12px 16px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+    transition: all 0.3s ease;
+}
+
+.duplicates-banner .banner-content {
+    max-width: 1400px;
+    margin: 0 auto;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.duplicates-banner i.fa-exclamation-triangle {
+    font-size: 18px;
+    color: oklch(var(--lora-warning));
+}
+
+.duplicates-banner .banner-actions {
+    margin-left: auto;
+    display: flex;
+    gap: 8px;
+    align-items: center;
+}
+
+.duplicates-banner button {
+    min-width: 100px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 4px;
+    border-radius: var(--border-radius-xs);
+    padding: 4px 10px;
+    border: 1px solid var(--border-color);
+    background: var(--card-bg);
+    color: var(--text-color);
+    font-size: 0.85em;
+    transition: all 0.2s ease;
+    cursor: pointer;
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+
+.duplicates-banner button:hover {
+    border-color: var(--lora-accent);
+    background: var(--bg-color);
+    transform: translateY(-1px);
+    box-shadow: 0 3px 5px rgba(0, 0, 0, 0.08);
+}
+
+.duplicates-banner button.btn-exit {
+    min-width: unset;
+    width: 28px;
+    height: 28px;
+    padding: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+}
+
+.duplicates-banner button.disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+/* Duplicate groups */
+.duplicate-group {
+    position: relative;
+    border: 2px solid oklch(var(--lora-warning));
+    border-radius: var(--border-radius-base);
+    padding: 16px;
+    margin-bottom: 24px;
+    background: var(--card-bg);
+}
+
+.duplicate-group-header {
+    background-color: var(--bg-color);
+    color: var(--text-color);
+    border: 1px solid var(--border-color);
+    padding: 8px 16px;
+    border-radius: var(--border-radius-xs);
+    margin-bottom: 16px;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.duplicate-group-header span:last-child {
+    display: flex;
+    gap: 8px;
+    align-items: center;
+}
+
+.duplicate-group-header button {
+    min-width: 80px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 4px;
+    border-radius: var(--border-radius-xs);
+    padding: 4px 8px;
+    border: 1px solid var(--border-color);
+    background: var(--card-bg);
+    color: var(--text-color);
+    font-size: 0.85em;
+    transition: all 0.2s ease;
+    cursor: pointer;
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+    margin-left: 8px;
+}
+
+.duplicate-group-header button:hover {
+    border-color: var(--lora-accent);
+    background: var(--bg-color);
+    transform: translateY(-1px);
+    box-shadow: 0 3px 5px rgba(0, 0, 0, 0.08);
+}
+
+.card-group-container {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 16px;
+    justify-content: flex-start;
+    align-items: flex-start;
+}
+
+/* Make cards in duplicate groups have consistent width */
+.card-group-container .lora-card {
+    flex: 0 0 auto;
+    width: 240px;
+    margin: 0;
+    cursor: pointer; /* Indicate the card is clickable */
+}
+
+/* Ensure the grid layout is only applied to the main recipe grid, not duplicate groups */
+.duplicate-mode .card-grid {
+    display: block;
+}
+
+/* Scrollable container for large duplicate groups */
+.card-group-container.scrollable {
+    max-height: 450px;
+    overflow-y: auto;
+    padding-right: 8px;
+}
+
+/* Add a toggle button to expand/collapse large duplicate groups */
+.group-toggle-btn {
+    position: absolute;
+    right: 16px;
+    bottom: -12px;
+    background: var(--card-bg);
+    color: var(--text-color);
+    border: 1px solid var(--border-color);
+    border-radius: 50%;
+    width: 24px;
+    height: 24px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    z-index: 1;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    transition: all 0.2s ease;
+}
+
+.group-toggle-btn:hover {
+    border-color: var(--lora-accent);
+    transform: translateY(-1px);
+    box-shadow: 0 3px 5px rgba(0, 0, 0, 0.08);
+}
+
+/* Duplicate card styling */
+.lora-card.duplicate {
+    position: relative;
+    transition: all 0.2s ease;
+}
+
+.lora-card.duplicate:hover {
+    border-color: var(--lora-accent);
+}
+
+.lora-card.duplicate.latest {
+    border-style: solid;
+    border-color: oklch(var(--lora-warning));
+}
+
+.lora-card.duplicate-selected {
+    border: 2px solid oklch(var(--lora-accent));
+    box-shadow: 0 0 8px rgba(0, 0, 0, 0.2);
+}
+
+.lora-card .selector-checkbox {
+    position: absolute;
+    top: 10px;
+    right: 10px;
+    z-index: 10;
+    width: 20px;
+    height: 20px;
+    cursor: pointer;
+}
+
+/* Latest indicator */
+.lora-card.duplicate.latest::after {
+    content: "Latest";
+    position: absolute;
+    top: 10px;
+    left: 10px;
+    background: oklch(var(--lora-accent));
+    color: white;
+    font-size: 12px;
+    padding: 2px 6px;
+    border-radius: var(--border-radius-xs);
+    z-index: 5;
+}
+
+/* Responsive adjustments */
+@media (max-width: 768px) {
+    .duplicates-banner .banner-content {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 8px;
+    }
+    
+    .duplicates-banner .banner-actions {
+        width: 100%;
+        margin-left: 0;
+        justify-content: space-between;
+    }
+    
+    .duplicate-group-header {
+        flex-direction: column;
+        gap: 8px;
+        align-items: flex-start;
+    }
+    
+    .duplicate-group-header span:last-child {
+        display: flex;
+        gap: 8px;
+        width: 100%;
+    }
+    
+    .duplicate-group-header button {
+        margin-left: 0;
+        flex: 1;
+    }
+}

static/css/components/import-modal.css

@@ -291,7 +291,7 @@
     gap: 8px;
     padding: var(--space-1);
     border: 1px solid var(--border-color);
-    border-radius: var(--border-radius-sm);
+    border-radius: var (--border-radius-sm);
     background: var(--lora-surface);
 }
 
@@ -733,3 +733,150 @@
     font-size: 0.9em;
     line-height: 1.4;
 }
+
+/* Duplicate Recipes Styles */
+.duplicate-recipes-container {
+    margin-bottom: var(--space-3);
+    border-radius: var(--border-radius-sm);
+    overflow: hidden;
+    animation: fadeIn 0.3s ease-in-out;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(-10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.duplicate-warning {
+    display: flex;
+    align-items: flex-start;
+    gap: 12px;
+    padding: 12px 16px;
+    background: oklch(var(--lora-warning) / 0.1);
+    border: 1px solid var(--lora-warning);
+    border-radius: var(--border-radius-sm) var(--border-radius-sm) 0 0;
+    color: var(--text-color);
+}
+
+.duplicate-warning .warning-icon {
+    color: var(--lora-warning);
+    font-size: 1.2em;
+    padding-top: 2px;
+}
+
+.duplicate-warning .warning-content {
+    flex: 1;
+}
+
+.duplicate-warning .warning-title {
+    font-weight: 600;
+    margin-bottom: 4px;
+}
+
+.duplicate-warning .warning-text {
+    font-size: 0.9em;
+    line-height: 1.4;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 8px;
+}
+
+.toggle-duplicates-btn {
+    background: none;
+    border: none;
+    color: var(--lora-warning);
+    cursor: pointer;
+    font-size: 0.9em;
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 4px 8px;
+    border-radius: var(--border-radius-xs);
+}
+
+.toggle-duplicates-btn:hover {
+    background: oklch(var(--lora-warning) / 0.1);
+}
+
+.duplicate-recipes-list {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
+    gap: 12px;
+    padding: 16px;
+    border: 1px solid var(--border-color);
+    border-top: none;
+    border-radius: 0 0 var(--border-radius-sm) var(--border-radius-sm);
+    background: var(--bg-color);
+    max-height: 300px;
+    overflow-y: auto;
+    transition: max-height 0.3s ease, padding 0.3s ease;
+}
+
+.duplicate-recipes-list.collapsed {
+    max-height: 0;
+    padding: 0 16px;
+    overflow: hidden;
+}
+
+.duplicate-recipe-card {
+    position: relative;
+    border-radius: var(--border-radius-sm);
+    overflow: hidden;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    transition: transform 0.2s ease;
+}
+
+.duplicate-recipe-card:hover {
+    transform: translateY(-2px);
+}
+
+.duplicate-recipe-preview {
+    width: 100%;
+    position: relative;
+    aspect-ratio: 2/3;
+    background: var(--bg-color);
+}
+
+.duplicate-recipe-preview img {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+
+.duplicate-recipe-title {
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    padding: 8px;
+    background: rgba(0, 0, 0, 0.7);
+    color: white;
+    font-size: 0.85em;
+    line-height: 1.3;
+    max-height: 50%;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+}
+
+.duplicate-recipe-details {
+    padding: 8px;
+    background: var(--bg-color);
+    font-size: 0.75em;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    color: var(--text-color);
+    opacity: 0.8;
+}
+
+.duplicate-recipe-date, 
+.duplicate-recipe-lora-count {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+}

static/css/components/lora-modal.css

@@ -1133,8 +1133,8 @@
     pointer-events: none;
 }
 
-/* Show metadata panel only on hover */
-.media-wrapper:hover .image-metadata-panel {
+/* Show metadata panel only when the 'visible' class is added */
+.media-wrapper .image-metadata-panel.visible {
     transform: translateY(0);
     opacity: 0.98;
     pointer-events: auto;

static/css/components/modal.css

@@ -44,26 +44,12 @@ body.modal-open {
 }
 
 /* Delete Modal specific styles */
-.delete-modal-content {
-    max-width: 500px;
-    text-align: center;
-}
 
 .delete-message {
     color: var(--text-color);
     margin: var(--space-2) 0;
 }
 
-.delete-model-info {
-    background: var(--lora-surface);
-    border: 1px solid var(--lora-border);
-    border-radius: var(--border-radius-sm);
-    padding: var(--space-2);
-    margin: var(--space-2) 0;
-    color: var(--text-color);
-    word-break: break-all;
-}
-
 /* Update delete modal styles */
 .delete-modal {
     display: none;  /* Set initial display to none */
@@ -92,7 +78,8 @@ body.modal-open {
     animation: modalFadeIn 0.2s ease-out;
 }
 
-.delete-model-info {
+.delete-model-info,
+.exclude-model-info {
     /* Update info display styling */
     background: var(--lora-surface);
     border: 1px solid var(--lora-border);
@@ -123,7 +110,7 @@ body.modal-open {
     margin-top: var(--space-3);
 }
 
-.cancel-btn, .delete-btn {
+.cancel-btn, .delete-btn, .exclude-btn {
     padding: 8px var(--space-2);
     border-radius: 6px;
     border: none;
@@ -143,6 +130,12 @@ body.modal-open {
     color: white;
 }
 
+/* Style for exclude button - different from delete button */
+.exclude-btn {
+    background: var(--lora-accent, #4f46e5);
+    color: white;
+}
+
 .cancel-btn:hover {
     background: var(--lora-border);
 }
@@ -151,6 +144,11 @@ body.modal-open {
     opacity: 0.9;
 }
 
+.exclude-btn:hover {
+    opacity: 0.9;
+    background: oklch(from var(--lora-accent, #4f46e5) l c h / 85%);
+}
+
 .modal-content h2 {
     color: var(--text-color);
     margin-bottom: var(--space-2);
@@ -587,7 +585,7 @@ input:checked + .toggle-slider:before {
     border-radius: var(--border-radius-xs);
     border: 1px solid var(--border-color);
     background-color: var(--lora-surface);
-    color: var(--text-color);
+    color: var (--text-color);
     font-size: 0.95em;
     height: 32px;
 }
@@ -674,4 +672,14 @@ input:checked + .toggle-slider:before {
 
 .changelog-item a:hover {
     text-decoration: underline;
+}
+
+/* Add warning text style for settings */
+.warning-text {
+    color: var(--lora-warning, #e67e22);
+    font-weight: 500;
+}
+
+[data-theme="dark"] .warning-text {
+    color: var(--lora-warning, #f39c12);
 }

static/css/components/progress-panel.css

@@ -12,11 +12,13 @@
     transition: transform 0.3s ease, opacity 0.3s ease;
     opacity: 0;
     transform: translateY(20px);
+    pointer-events: none; /* Ignore mouse events when invisible */
 }
 
 .progress-panel.visible {
     opacity: 1;
     transform: translateY(0);
+    pointer-events: auto; /* Capture mouse events when visible */
 }
 
 .progress-panel.collapsed .progress-panel-content {

static/css/components/recipe-modal.css

@@ -229,8 +229,10 @@
     background: var(--lora-surface);
     border: 1px solid var(--border-color);
     display: flex;
+    flex-direction: column;
     align-items: center;
     justify-content: center;
+    position: relative;
 }
 
 .recipe-preview-container img,
@@ -246,6 +248,133 @@
     object-fit: contain;
 }
 
+/* Source URL container */
+.source-url-container {
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    background: rgba(0, 0, 0, 0.5);
+    padding: 8px 12px;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    transition: transform 0.3s ease;
+    transform: translateY(100%);
+}
+
+.recipe-preview-container:hover .source-url-container {
+    transform: translateY(0);
+}
+
+.source-url-container.active {
+    transform: translateY(0);
+}
+
+.source-url-content {
+    display: flex;
+    align-items: center;
+    color: #fff;
+    flex: 1;
+    overflow: hidden;
+    font-size: 0.85em;
+}
+
+.source-url-icon {
+    margin-right: 8px;
+    flex-shrink: 0;
+}
+
+.source-url-text {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    cursor: pointer;
+    flex: 1;
+}
+
+.source-url-edit-btn {
+    background: none;
+    border: none;
+    color: #fff;
+    cursor: pointer;
+    padding: 4px;
+    margin-left: 8px;
+    border-radius: var(--border-radius-xs);
+    opacity: 0.7;
+    transition: opacity 0.2s ease;
+    flex-shrink: 0;
+}
+
+.source-url-edit-btn:hover {
+    opacity: 1;
+    background: rgba(255, 255, 255, 0.1);
+}
+
+/* Source URL editor */
+.source-url-editor {
+    display: none;
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    background: var(--bg-color);
+    border-top: 1px solid var(--border-color);
+    padding: 12px;
+    flex-direction: column;
+    gap: 10px;
+    z-index: 5;
+}
+
+.source-url-editor.active {
+    display: flex;
+}
+
+.source-url-input {
+    width: 100%;
+    padding: 8px 10px;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-xs);
+    background: var(--bg-color);
+    color: var(--text-color);
+    font-size: 0.9em;
+}
+
+.source-url-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 8px;
+}
+
+.source-url-cancel-btn, 
+.source-url-save-btn {
+    padding: 6px 12px;
+    border-radius: var(--border-radius-xs);
+    font-size: 0.85em;
+    cursor: pointer;
+    border: none;
+    transition: all 0.2s;
+}
+
+.source-url-cancel-btn {
+    background: var(--bg-color);
+    color: var(--text-color);
+    border: 1px solid var(--border-color);
+}
+
+.source-url-save-btn {
+    background: var(--lora-accent);
+    color: white;
+}
+
+.source-url-cancel-btn:hover {
+    background: var(--lora-surface);
+}
+
+.source-url-save-btn:hover {
+    background: color-mix(in oklch, var(--lora-accent), black 10%);
+}
+
 /* Generation Parameters */
 .recipe-gen-params {
     height: 360px;

static/css/components/support-modal.css

@@ -117,9 +117,50 @@
     box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
 }
 
+/* QR Code section styles */
+.qrcode-toggle {
+    width: 100%;
+    margin-top: var(--space-2);
+    justify-content: center;
+    position: relative;
+}
+
+.qrcode-toggle .toggle-icon {
+    margin-left: 8px;
+    transition: transform 0.3s ease;
+}
+
+.qrcode-toggle.active .toggle-icon {
+    transform: rotate(180deg);
+}
+
+.qrcode-container {
+    max-height: 0;
+    overflow: hidden;
+    transition: max-height 0.4s ease, opacity 0.3s ease;
+    opacity: 0;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+}
+
+.qrcode-container.show {
+    max-height: 500px;
+    opacity: 1;
+    margin-top: var(--space-3);
+}
+
+.qrcode-image {
+    max-width: 80%;
+    height: auto;
+    border-radius: var(--border-radius-sm);
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    border: 1px solid var(--lora-border);
+    aspect-ratio: 1/1; /* Ensure proper aspect ratio for the square QR code */
+}
+
 .support-footer {
     text-align: center;
-    margin-top: var(--space-1);
     font-style: italic;
     color: var(--text-color);
 }

static/css/layout.css

@@ -15,6 +15,19 @@
     z-index: var(--z-base);
 }
 
+/* Responsive container for larger screens */
+@media (min-width: 2000px) {
+    .container {
+        max-width: 1800px;
+    }
+}
+
+@media (min-width: 3000px) {
+    .container {
+        max-width: 2400px;
+    }
+}
+
 .controls {
     display: flex;
     flex-direction: column;

static/css/style.css

@@ -21,6 +21,8 @@
 @import 'components/filter-indicator.css';
 @import 'components/initialization.css';
 @import 'components/progress-panel.css';
+@import 'components/alphabet-bar.css'; /* Add alphabet bar component */
+@import 'components/duplicates.css'; /* Add duplicates component */
 
 .initialization-notice {
     display: flex;

static/js/api/baseModelApi.js

@@ -1,7 +1,6 @@
 // filepath: d:\Workspace\ComfyUI\custom_nodes\ComfyUI-Lora-Manager\static\js\api\baseModelApi.js
 import { state, getCurrentPageState } from '../state/index.js';
 import { showToast } from '../utils/uiHelpers.js';
-import { showDeleteModal, confirmDelete } from '../utils/modalUtils.js';
 import { getSessionItem, saveMapToStorage } from '../utils/storageHelpers.js';
 
 /**
@@ -49,6 +48,11 @@ export async function loadMoreModels(options = {}) {
         if (pageState.showFavoritesOnly) {
             params.append('favorites_only', 'true');
         }
+        
+        // Add active letter filter if set
+        if (pageState.activeLetterFilter) {
+            params.append('first_letter', pageState.activeLetterFilter);
+        }
 
         // Add search parameters if there's a search term
         if (pageState.filters?.search) {
@@ -155,6 +159,231 @@ export async function loadMoreModels(options = {}) {
     }
 }
 
+// New method for virtual scrolling fetch
+export async function fetchModelsPage(options = {}) {
+    const {
+        modelType = 'lora',
+        page = 1,
+        pageSize = 100,
+        endpoint = '/api/loras'
+    } = options;
+
+    const pageState = getCurrentPageState();
+    
+    try {
+        const params = new URLSearchParams({
+            page: page,
+            page_size: pageSize || pageState.pageSize || 20,
+            sort_by: pageState.sortBy
+        });
+        
+        if (pageState.activeFolder !== null) {
+            params.append('folder', pageState.activeFolder);
+        }
+
+        // Add favorites filter parameter if enabled
+        if (pageState.showFavoritesOnly) {
+            params.append('favorites_only', 'true');
+        }
+        
+        // Add active letter filter if set
+        if (pageState.activeLetterFilter) {
+            params.append('first_letter', pageState.activeLetterFilter);
+        }
+
+        // Add search parameters if there's a search term
+        if (pageState.filters?.search) {
+            params.append('search', pageState.filters.search);
+            params.append('fuzzy', 'true');
+            
+            // Add search option parameters if available
+            if (pageState.searchOptions) {
+                params.append('search_filename', pageState.searchOptions.filename.toString());
+                params.append('search_modelname', pageState.searchOptions.modelname.toString());
+                if (pageState.searchOptions.tags !== undefined) {
+                    params.append('search_tags', pageState.searchOptions.tags.toString());
+                }
+                params.append('recursive', (pageState.searchOptions?.recursive ?? false).toString());
+            }
+        }
+        
+        // Add filter parameters if active
+        if (pageState.filters) {
+            // Handle tags filters
+            if (pageState.filters.tags && pageState.filters.tags.length > 0) {
+                // Checkpoints API expects individual 'tag' parameters, Loras API expects comma-separated 'tags'
+                if (modelType === 'checkpoint') {
+                    pageState.filters.tags.forEach(tag => {
+                        params.append('tag', tag);
+                    });
+                } else {
+                    params.append('tags', pageState.filters.tags.join(','));
+                }
+            }
+            
+            // Handle base model filters
+            if (pageState.filters.baseModel && pageState.filters.baseModel.length > 0) {
+                if (modelType === 'checkpoint') {
+                    pageState.filters.baseModel.forEach(model => {
+                        params.append('base_model', model);
+                    });
+                } else {
+                    params.append('base_models', pageState.filters.baseModel.join(','));
+                }
+            }
+        }
+
+        // Add model-specific parameters
+        if (modelType === 'lora') {
+            // Check for recipe-based filtering parameters from session storage
+            const filterLoraHash = getSessionItem('recipe_to_lora_filterLoraHash');
+            const filterLoraHashes = getSessionItem('recipe_to_lora_filterLoraHashes');
+
+            // Add hash filter parameter if present
+            if (filterLoraHash) {
+                params.append('lora_hash', filterLoraHash);
+            } 
+            // Add multiple hashes filter if present
+            else if (filterLoraHashes) {
+                try {
+                    if (Array.isArray(filterLoraHashes) && filterLoraHashes.length > 0) {
+                        params.append('lora_hashes', filterLoraHashes.join(','));
+                    }
+                } catch (error) {
+                    console.error('Error parsing lora hashes from session storage:', error);
+                }
+            }
+        }
+
+        const response = await fetch(`${endpoint}?${params}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch models: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        
+        return {
+            items: data.items,
+            totalItems: data.total,
+            totalPages: data.total_pages,
+            currentPage: page,
+            hasMore: page < data.total_pages,
+            folders: data.folders
+        };
+        
+    } catch (error) {
+        console.error(`Error fetching ${modelType}s:`, error);
+        showToast(`Failed to fetch ${modelType}s: ${error.message}`, 'error');
+        throw error;
+    }
+}
+
+/**
+ * Reset and reload models using virtual scrolling
+ * @param {Object} options - Operation options
+ * @returns {Promise<Object>} The fetch result
+ */
+export async function resetAndReloadWithVirtualScroll(options = {}) {
+    const {
+        modelType = 'lora',
+        updateFolders = false,
+        fetchPageFunction
+    } = options;
+    
+    const pageState = getCurrentPageState();
+    
+    try {
+        pageState.isLoading = true;
+        document.body.classList.add('loading');
+        
+        // Reset page counter
+        pageState.currentPage = 1;
+        
+        // Fetch the first page
+        const result = await fetchPageFunction(1, pageState.pageSize || 50);
+        
+        // Update the virtual scroller
+        state.virtualScroller.refreshWithData(
+            result.items,
+            result.totalItems,
+            result.hasMore
+        );
+        
+        // Update state
+        pageState.hasMore = result.hasMore;
+        pageState.currentPage = 2; // Next page will be 2
+        
+        // Update folders if needed
+        if (updateFolders && result.folders) {
+            updateFolderTags(result.folders);
+        }
+        
+        return result;
+    } catch (error) {
+        console.error(`Error reloading ${modelType}s:`, error);
+        showToast(`Failed to reload ${modelType}s: ${error.message}`, 'error');
+        throw error;
+    } finally {
+        pageState.isLoading = false;
+        document.body.classList.remove('loading');
+    }
+}
+
+/**
+ * Load more models using virtual scrolling
+ * @param {Object} options - Operation options
+ * @returns {Promise<Object>} The fetch result
+ */
+export async function loadMoreWithVirtualScroll(options = {}) {
+    const {
+        modelType = 'lora',
+        resetPage = false,
+        updateFolders = false,
+        fetchPageFunction
+    } = options;
+    
+    const pageState = getCurrentPageState();
+    
+    try {
+        // Start loading state
+        pageState.isLoading = true;
+        document.body.classList.add('loading');
+        
+        // Reset to first page if requested
+        if (resetPage) {
+            pageState.currentPage = 1;
+        }
+        
+        // Fetch the first page of data
+        const result = await fetchPageFunction(pageState.currentPage, pageState.pageSize || 50);
+        
+        // Update virtual scroller with the new data
+        state.virtualScroller.refreshWithData(
+            result.items,
+            result.totalItems,
+            result.hasMore
+        );
+        
+        // Update state
+        pageState.hasMore = result.hasMore;
+        pageState.currentPage = 2; // Next page to load would be 2
+        
+        // Update folders if needed
+        if (updateFolders && result.folders) {
+            updateFolderTags(result.folders);
+        }
+        
+        return result;
+    } catch (error) {
+        console.error(`Error loading ${modelType}s:`, error);
+        showToast(`Failed to load ${modelType}s: ${error.message}`, 'error');
+        throw error;
+    } finally {
+        pageState.isLoading = false;
+        document.body.classList.remove('loading');
+    }
+}
+
 // Update folder tags in the UI
 export function updateFolderTags(folders) {
     const folderTagsContainer = document.querySelector('.folder-tags');
@@ -203,13 +432,49 @@ export function replaceModelPreview(filePath, modelType = 'lora') {
 }
 
 // Delete a model (generic)
-export function deleteModel(filePath, modelType = 'lora') {
-    if (modelType === 'checkpoint') {
-        confirmDelete('Are you sure you want to delete this checkpoint?', () => {
-            performDelete(filePath, modelType);
+export async function deleteModel(filePath, modelType = 'lora') {
+    try {
+        const endpoint = modelType === 'checkpoint' 
+            ? '/api/checkpoints/delete' 
+            : '/api/delete_model';
+            
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                file_path: filePath
+            })
         });
-    } else {
-        showDeleteModal(filePath);
+        
+        if (!response.ok) {
+            throw new Error(`Failed to delete ${modelType}: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            // If virtual scroller exists, update its data
+            if (state.virtualScroller) {
+                state.virtualScroller.removeItemByFilePath(filePath);
+            } else {
+                // Legacy approach: remove the card from UI directly
+                const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
+                if (card) {
+                    card.remove();
+                }
+            }
+            
+            showToast(`${modelType} deleted successfully`, 'success');
+            return true;
+        } else {
+            throw new Error(data.error || `Failed to delete ${modelType}`);
+        }
+    } catch (error) {
+        console.error(`Error deleting ${modelType}:`, error);
+        showToast(`Failed to delete ${modelType}: ${error.message}`, 'error');
+        return false;
     }
 }
 
@@ -247,7 +512,7 @@ export async function refreshModels(options = {}) {
         }
         
         if (typeof resetAndReloadFunction === 'function') {
-            await resetAndReloadFunction();
+            await resetAndReloadFunction(true); // update folders
         }
         
         showToast(`Refresh complete`, 'success');
@@ -389,6 +654,53 @@ export async function refreshSingleModelMetadata(filePath, modelType = 'lora') {
     }
 }
 
+// Generic function to exclude a model
+export async function excludeModel(filePath, modelType = 'lora') {
+    try {
+        const endpoint = modelType === 'checkpoint' 
+            ? '/api/checkpoints/exclude' 
+            : '/api/loras/exclude';
+            
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                file_path: filePath
+            })
+        });
+        
+        if (!response.ok) {
+            throw new Error(`Failed to exclude ${modelType}: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            // If virtual scroller exists, update its data
+            if (state.virtualScroller) {
+                state.virtualScroller.removeItemByFilePath(filePath);
+            } else {
+                // Legacy approach: remove the card from UI directly
+                const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
+                if (card) {
+                    card.remove();
+                }
+            }
+            
+            showToast(`${modelType} excluded successfully`, 'success');
+            return true;
+        } else {
+            throw new Error(data.error || `Failed to exclude ${modelType}`);
+        }
+    } catch (error) {
+        console.error(`Error excluding ${modelType}:`, error);
+        showToast(`Failed to exclude ${modelType}: ${error.message}`, 'error');
+        return false;
+    }
+}
+
 // Private methods
 
 // Upload a preview image

static/js/api/checkpointApi.js

@@ -1,32 +1,78 @@
 import { createCheckpointCard } from '../components/CheckpointCard.js';
 import {
     loadMoreModels,
+    fetchModelsPage,
     resetAndReload as baseResetAndReload,
+    resetAndReloadWithVirtualScroll,
+    loadMoreWithVirtualScroll,
     refreshModels as baseRefreshModels,
     deleteModel as baseDeleteModel,
     replaceModelPreview,
     fetchCivitaiMetadata,
-    refreshSingleModelMetadata
+    refreshSingleModelMetadata,
+    excludeModel as baseExcludeModel
 } from './baseModelApi.js';
+import { state } from '../state/index.js';
 
-// Load more checkpoints with pagination
-export async function loadMoreCheckpoints(resetPagination = true) {
-    return loadMoreModels({
-        resetPage: resetPagination,
-        updateFolders: true,
+/**
+ * Fetch checkpoints with pagination for virtual scrolling
+ * @param {number} page - Page number to fetch
+ * @param {number} pageSize - Number of items per page
+ * @returns {Promise<Object>} Object containing items, total count, and pagination info
+ */
+export async function fetchCheckpointsPage(page = 1, pageSize = 100) {
+    return fetchModelsPage({
         modelType: 'checkpoint',
-        createCardFunction: createCheckpointCard,
+        page,
+        pageSize,
         endpoint: '/api/checkpoints'
     });
 }
 
+/**
+ * Load more checkpoints with pagination - updated to work with VirtualScroller
+ * @param {boolean} resetPage - Whether to reset to the first page
+ * @param {boolean} updateFolders - Whether to update folder tags
+ * @returns {Promise<void>}
+ */
+export async function loadMoreCheckpoints(resetPage = false, updateFolders = false) {
+    // Check if virtual scroller is available
+    if (state.virtualScroller) {
+        return loadMoreWithVirtualScroll({
+            modelType: 'checkpoint',
+            resetPage,
+            updateFolders,
+            fetchPageFunction: fetchCheckpointsPage
+        });
+    } else {
+        // Fall back to the original implementation if virtual scroller isn't available
+        return loadMoreModels({
+            resetPage,
+            updateFolders,
+            modelType: 'checkpoint',
+            createCardFunction: createCheckpointCard,
+            endpoint: '/api/checkpoints'
+        });
+    }
+}
+
 // Reset and reload checkpoints
-export async function resetAndReload() {
-    return baseResetAndReload({
-        updateFolders: true,
-        modelType: 'checkpoint',
-        loadMoreFunction: loadMoreCheckpoints
-    });
+export async function resetAndReload(updateFolders = false) {
+    // Check if virtual scroller is available
+    if (state.virtualScroller) {
+        return resetAndReloadWithVirtualScroll({
+            modelType: 'checkpoint',
+            updateFolders,
+            fetchPageFunction: fetchCheckpointsPage
+        });
+    } else {
+        // Fall back to original implementation
+        return baseResetAndReload({
+            updateFolders,
+            modelType: 'checkpoint',
+            loadMoreFunction: loadMoreCheckpoints
+        });
+    }
 }
 
 // Refresh checkpoints
@@ -59,7 +105,11 @@ export async function fetchCivitai() {
 
 // Refresh single checkpoint metadata
 export async function refreshSingleCheckpointMetadata(filePath) {
-    return refreshSingleModelMetadata(filePath, 'checkpoint');
+    const success = await refreshSingleModelMetadata(filePath, 'checkpoint');
+    if (success) {
+        // Reload the current view to show updated data
+        await resetAndReload();
+    }
 }
 
 /**
@@ -85,4 +135,13 @@ export async function saveModelMetadata(filePath, data) {
     }
     
     return response.json();
+}
+
+/**
+ * Exclude a checkpoint model from being shown in the UI
+ * @param {string} filePath - File path of the checkpoint to exclude
+ * @returns {Promise<boolean>} Promise resolving to success status
+ */
+export function excludeCheckpoint(filePath) {
+    return baseExcludeModel(filePath, 'checkpoint');
 }

static/js/api/loraApi.js

@@ -1,13 +1,18 @@
 import { createLoraCard } from '../components/LoraCard.js';
 import {
     loadMoreModels,
+    fetchModelsPage,
     resetAndReload as baseResetAndReload,
+    resetAndReloadWithVirtualScroll,
+    loadMoreWithVirtualScroll,
     refreshModels as baseRefreshModels,
     deleteModel as baseDeleteModel,
     replaceModelPreview,
     fetchCivitaiMetadata,
-    refreshSingleModelMetadata
+    refreshSingleModelMetadata,
+    excludeModel as baseExcludeModel
 } from './baseModelApi.js';
+import { state, getCurrentPageState } from '../state/index.js';
 
 /**
  * Save model metadata to the server
@@ -34,12 +39,55 @@ export async function saveModelMetadata(filePath, data) {
     return response.json();
 }
 
+/**
+ * Exclude a lora model from being shown in the UI
+ * @param {string} filePath - File path of the model to exclude
+ * @returns {Promise<boolean>} Promise resolving to success status
+ */
+export async function excludeLora(filePath) {
+    return baseExcludeModel(filePath, 'lora');
+}
+
+/**
+ * Load more loras with pagination - updated to work with VirtualScroller
+ * @param {boolean} resetPage - Whether to reset to the first page
+ * @param {boolean} updateFolders - Whether to update folder tags
+ * @returns {Promise<void>}
+ */
 export async function loadMoreLoras(resetPage = false, updateFolders = false) {
-    return loadMoreModels({
-        resetPage,
-        updateFolders,
+    const pageState = getCurrentPageState();
+    
+    // Check if virtual scroller is available
+    if (state.virtualScroller) {
+        return loadMoreWithVirtualScroll({
+            modelType: 'lora',
+            resetPage,
+            updateFolders,
+            fetchPageFunction: fetchLorasPage
+        });
+    } else {
+        // Fall back to the original implementation if virtual scroller isn't available
+        return loadMoreModels({
+            resetPage,
+            updateFolders,
+            modelType: 'lora',
+            createCardFunction: createLoraCard,
+            endpoint: '/api/loras'
+        });
+    }
+}
+
+/**
+ * Fetch loras with pagination for virtual scrolling
+ * @param {number} page - Page number to fetch
+ * @param {number} pageSize - Number of items per page
+ * @returns {Promise<Object>} Object containing items, total count, and pagination info
+ */
+export async function fetchLorasPage(page = 1, pageSize = 100) {
+    return fetchModelsPage({
         modelType: 'lora',
-        createCardFunction: createLoraCard,
+        page,
+        pageSize,
         endpoint: '/api/loras'
     });
 }
@@ -61,21 +109,38 @@ export async function replacePreview(filePath) {
 }
 
 export function appendLoraCards(loras) {
-    const grid = document.getElementById('loraGrid');
-    const sentinel = document.getElementById('scroll-sentinel');
-    
-    loras.forEach(lora => {
-        const card = createLoraCard(lora);
-        grid.appendChild(card);
-    });
+    // This function is no longer needed with virtual scrolling
+    // but kept for compatibility
+    if (state.virtualScroller) {
+        console.warn('appendLoraCards is deprecated when using virtual scrolling');
+    } else {
+        const grid = document.getElementById('loraGrid');
+        
+        loras.forEach(lora => {
+            const card = createLoraCard(lora);
+            grid.appendChild(card);
+        });
+    }
 }
 
 export async function resetAndReload(updateFolders = false) {
-    return baseResetAndReload({
-        updateFolders,
-        modelType: 'lora',
-        loadMoreFunction: loadMoreLoras
-    });
+    const pageState = getCurrentPageState();
+    
+    // Check if virtual scroller is available
+    if (state.virtualScroller) {
+        return resetAndReloadWithVirtualScroll({
+            modelType: 'lora',
+            updateFolders,
+            fetchPageFunction: fetchLorasPage
+        });
+    } else {
+        // Fall back to original implementation
+        return baseResetAndReload({
+            updateFolders,
+            modelType: 'lora',
+            loadMoreFunction: loadMoreLoras
+        });
+    }
 }
 
 export async function refreshLoras() {

static/js/api/recipeApi.js

@@ -0,0 +1,174 @@
+import { RecipeCard } from '../components/RecipeCard.js';
+import {
+    fetchModelsPage,
+    resetAndReloadWithVirtualScroll,
+    loadMoreWithVirtualScroll
+} from './baseModelApi.js';
+import { state, getCurrentPageState } from '../state/index.js';
+import { showToast } from '../utils/uiHelpers.js';
+
+/**
+ * Fetch recipes with pagination for virtual scrolling
+ * @param {number} page - Page number to fetch
+ * @param {number} pageSize - Number of items per page
+ * @returns {Promise<Object>} Object containing items, total count, and pagination info
+ */
+export async function fetchRecipesPage(page = 1, pageSize = 100) {
+    const pageState = getCurrentPageState();
+    
+    try {
+        const params = new URLSearchParams({
+            page: page,
+            page_size: pageSize || pageState.pageSize || 20,
+            sort_by: pageState.sortBy
+        });
+        
+        // If we have a specific recipe ID to load
+        if (pageState.customFilter?.active && pageState.customFilter?.recipeId) {
+            // Special case: load specific recipe
+            const response = await fetch(`/api/recipe/${pageState.customFilter.recipeId}`);
+            
+            if (!response.ok) {
+                throw new Error(`Failed to load recipe: ${response.statusText}`);
+            }
+            
+            const recipe = await response.json();
+            
+            // Return in expected format
+            return {
+                items: [recipe],
+                totalItems: 1,
+                totalPages: 1,
+                currentPage: 1,
+                hasMore: false
+            };
+        }
+        
+        // Add custom filter for Lora if present
+        if (pageState.customFilter?.active && pageState.customFilter?.loraHash) {
+            params.append('lora_hash', pageState.customFilter.loraHash);
+            params.append('bypass_filters', 'true');
+        } else {
+            // Normal filtering logic
+            
+            // Add search filter if present
+            if (pageState.filters?.search) {
+                params.append('search', pageState.filters.search);
+                
+                // Add search option parameters
+                if (pageState.searchOptions) {
+                    params.append('search_title', pageState.searchOptions.title.toString());
+                    params.append('search_tags', pageState.searchOptions.tags.toString());
+                    params.append('search_lora_name', pageState.searchOptions.loraName.toString());
+                    params.append('search_lora_model', pageState.searchOptions.loraModel.toString());
+                    params.append('fuzzy', 'true');
+                }
+            }
+            
+            // Add base model filters
+            if (pageState.filters?.baseModel && pageState.filters.baseModel.length) {
+                params.append('base_models', pageState.filters.baseModel.join(','));
+            }
+            
+            // Add tag filters
+            if (pageState.filters?.tags && pageState.filters.tags.length) {
+                params.append('tags', pageState.filters.tags.join(','));
+            }
+        }
+
+        // Fetch recipes
+        const response = await fetch(`/api/recipes?${params.toString()}`);
+        
+        if (!response.ok) {
+            throw new Error(`Failed to load recipes: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        
+        return {
+            items: data.items,
+            totalItems: data.total,
+            totalPages: data.total_pages,
+            currentPage: page,
+            hasMore: page < data.total_pages
+        };
+    } catch (error) {
+        console.error('Error fetching recipes:', error);
+        showToast(`Failed to fetch recipes: ${error.message}`, 'error');
+        throw error;
+    }
+}
+
+/**
+ * Reset and reload recipes using virtual scrolling
+ * @param {boolean} updateFolders - Whether to update folder tags
+ * @returns {Promise<Object>} The fetch result
+ */
+export async function resetAndReload(updateFolders = false) {
+    return resetAndReloadWithVirtualScroll({
+        modelType: 'recipe',
+        updateFolders,
+        fetchPageFunction: fetchRecipesPage
+    });
+}
+
+/**
+ * Refreshes the recipe list by first rebuilding the cache and then loading recipes
+ */
+export async function refreshRecipes() {
+    try {
+        state.loadingManager.showSimpleLoading('Refreshing recipes...');
+        
+        // Call the API endpoint to rebuild the recipe cache
+        const response = await fetch('/api/recipes/scan');
+        
+        if (!response.ok) {
+            const data = await response.json();
+            throw new Error(data.error || 'Failed to refresh recipe cache');
+        }
+        
+        // After successful cache rebuild, reload the recipes
+        await resetAndReload();
+        
+        showToast('Refresh complete', 'success');
+    } catch (error) {
+        console.error('Error refreshing recipes:', error);
+        showToast(error.message || 'Failed to refresh recipes', 'error');
+    } finally {
+        state.loadingManager.hide();
+        state.loadingManager.restoreProgressBar();
+    }
+}
+
+/**
+ * Load more recipes with pagination - updated to work with VirtualScroller
+ * @param {boolean} resetPage - Whether to reset to the first page
+ * @returns {Promise<void>}
+ */
+export async function loadMoreRecipes(resetPage = false) {
+    const pageState = getCurrentPageState();
+    
+    // Use virtual scroller if available
+    if (state.virtualScroller) {
+        return loadMoreWithVirtualScroll({
+            modelType: 'recipe',
+            resetPage,
+            updateFolders: false,
+            fetchPageFunction: fetchRecipesPage
+        });
+    }
+}
+
+/**
+ * Create a recipe card instance from recipe data
+ * @param {Object} recipe - Recipe data
+ * @returns {HTMLElement} Recipe card DOM element
+ */
+export function createRecipeCard(recipe) {
+    const recipeCard = new RecipeCard(recipe, (recipe) => {
+        if (window.recipeManager) {
+            window.recipeManager.showRecipeDetails(recipe);
+        }
+    });
+    return recipeCard.element;
+}

static/js/checkpoints.js

@@ -1,6 +1,5 @@
 import { appCore } from './core.js';
-import { initializeInfiniteScroll } from './utils/infiniteScroll.js';
-import { confirmDelete, closeDeleteModal } from './utils/modalUtils.js';
+import { confirmDelete, closeDeleteModal, confirmExclude, closeExcludeModal } from './utils/modalUtils.js';
 import { createPageControls } from './components/controls/index.js';
 import { loadMoreCheckpoints } from './api/checkpointApi.js';
 import { CheckpointDownloadManager } from './managers/CheckpointDownloadManager.js';
@@ -23,6 +22,8 @@ class CheckpointsPageManager {
         // Minimal set of functions that need to remain global
         window.confirmDelete = confirmDelete;
         window.closeDeleteModal = closeDeleteModal;
+        window.confirmExclude = confirmExclude;
+        window.closeExcludeModal = closeExcludeModal;
         
         // Add loadCheckpoints function to window for FilterManager compatibility
         window.checkpointManager = {
@@ -38,9 +39,6 @@ class CheckpointsPageManager {
         // Initialize context menu
         new CheckpointContextMenu();
         
-        // Initialize infinite scroll
-        initializeInfiniteScroll('checkpoints');
-        
         // Initialize common page features
         appCore.initializePageFeatures();
         

static/js/components/CheckpointCard.js

@@ -3,6 +3,7 @@ import { state } from '../state/index.js';
 import { showCheckpointModal } from './checkpointModal/index.js';
 import { NSFW_LEVELS } from '../utils/constants.js';
 import { replaceCheckpointPreview as apiReplaceCheckpointPreview, saveModelMetadata } from '../api/checkpointApi.js';
+import { showDeleteModal } from '../utils/modalUtils.js';
 
 export function createCheckpointCard(checkpoint) {
     const card = document.createElement('div');
@@ -262,7 +263,7 @@ export function createCheckpointCard(checkpoint) {
     // Delete button click event
     card.querySelector('.fa-trash')?.addEventListener('click', e => {
         e.stopPropagation();
-        deleteCheckpoint(checkpoint.file_path);
+        showDeleteModal(checkpoint.file_path);
     });
 
     // Replace preview button click event
@@ -322,17 +323,6 @@ function openCivitai(modelName) {
     }
 }
 
-function deleteCheckpoint(filePath) {
-    if (window.deleteCheckpoint) {
-        window.deleteCheckpoint(filePath);
-    } else {
-        // Use the modal delete functionality
-        import('../utils/modalUtils.js').then(({ showDeleteModal }) => {
-            showDeleteModal(filePath, 'checkpoint');
-        });
-    }
-}
-
 function replaceCheckpointPreview(filePath) {
     if (window.replaceCheckpointPreview) {
         window.replaceCheckpointPreview(filePath);

static/js/components/ContextMenu/CheckpointContextMenu.js

@@ -3,6 +3,7 @@ import { refreshSingleCheckpointMetadata, saveModelMetadata } from '../../api/ch
 import { showToast, getNSFWLevelName } from '../../utils/uiHelpers.js';
 import { NSFW_LEVELS } from '../../utils/constants.js';
 import { getStorageItem } from '../../utils/storageHelpers.js';
+import { showExcludeModal } from '../../utils/modalUtils.js';
 
 export class CheckpointContextMenu extends BaseContextMenu {
     constructor() {
@@ -61,6 +62,10 @@ export class CheckpointContextMenu extends BaseContextMenu {
                 // Move to folder (placeholder)
                 showToast('Move to folder feature coming soon', 'info');
                 break;
+            case 'exclude':
+                showExcludeModal(this.currentCard.dataset.filepath, 'checkpoint');
+                break;
+
         }
     }
 

static/js/components/ContextMenu/LoraContextMenu.js

@@ -3,6 +3,7 @@ import { refreshSingleLoraMetadata, saveModelMetadata } from '../../api/loraApi.
 import { showToast, getNSFWLevelName } from '../../utils/uiHelpers.js';
 import { NSFW_LEVELS } from '../../utils/constants.js';
 import { getStorageItem } from '../../utils/storageHelpers.js';
+import { showExcludeModal } from '../../utils/modalUtils.js';
 
 export class LoraContextMenu extends BaseContextMenu {
     constructor() {
@@ -51,6 +52,9 @@ export class LoraContextMenu extends BaseContextMenu {
             case 'set-nsfw':
                 this.showNSFWLevelSelector(null, null, this.currentCard);
                 break;
+            case 'exclude':
+                showExcludeModal(this.currentCard.dataset.filepath);
+                break;
         }
     }
 

static/js/components/DuplicatesManager.js

@@ -0,0 +1,402 @@
+// Duplicates Manager Component
+import { showToast } from '../utils/uiHelpers.js';
+import { RecipeCard } from './RecipeCard.js';
+import { state, getCurrentPageState } from '../state/index.js';
+import { initializeInfiniteScroll } from '../utils/infiniteScroll.js';
+
+export class DuplicatesManager {
+    constructor(recipeManager) {
+        this.recipeManager = recipeManager;
+        this.duplicateGroups = [];
+        this.inDuplicateMode = false;
+        this.selectedForDeletion = new Set();
+    }
+    
+    async findDuplicates() {
+        try {
+            document.body.classList.add('loading');
+            
+            const response = await fetch('/api/recipes/find-duplicates');
+            if (!response.ok) {
+                throw new Error('Failed to find duplicates');
+            }
+            
+            const data = await response.json();
+            if (!data.success) {
+                throw new Error(data.error || 'Unknown error finding duplicates');
+            }
+            
+            this.duplicateGroups = data.duplicate_groups || [];
+            
+            if (this.duplicateGroups.length === 0) {
+                showToast('No duplicate recipes found', 'info');
+                return false;
+            }
+            
+            this.enterDuplicateMode();
+            return true;
+        } catch (error) {
+            console.error('Error finding duplicates:', error);
+            showToast('Failed to find duplicates: ' + error.message, 'error');
+            return false;
+        } finally {
+            document.body.classList.remove('loading');
+        }
+    }
+    
+    enterDuplicateMode() {
+        this.inDuplicateMode = true;
+        this.selectedForDeletion.clear();
+        
+        // Update state
+        const pageState = getCurrentPageState();
+        pageState.duplicatesMode = true;
+        
+        // Show duplicates banner
+        const banner = document.getElementById('duplicatesBanner');
+        const countSpan = document.getElementById('duplicatesCount');
+        
+        if (banner && countSpan) {
+            countSpan.textContent = `Found ${this.duplicateGroups.length} duplicate group${this.duplicateGroups.length !== 1 ? 's' : ''}`;
+            banner.style.display = 'block';
+        }
+        
+        // Disable virtual scrolling if active
+        if (state.virtualScroller) {
+            state.virtualScroller.disable();
+        }
+        
+        // Add duplicate-mode class to the body
+        document.body.classList.add('duplicate-mode');
+        
+        // Render duplicate groups
+        this.renderDuplicateGroups();
+        
+        // Update selected count
+        this.updateSelectedCount();
+    }
+    
+    exitDuplicateMode() {
+        this.inDuplicateMode = false;
+        this.selectedForDeletion.clear();
+        
+        // Update state
+        const pageState = getCurrentPageState();
+        pageState.duplicatesMode = false;
+        
+        // Hide duplicates banner
+        const banner = document.getElementById('duplicatesBanner');
+        if (banner) {
+            banner.style.display = 'none';
+        }
+        
+        // Remove duplicate-mode class from the body
+        document.body.classList.remove('duplicate-mode');
+        
+        // Clear the recipe grid first
+        const recipeGrid = document.getElementById('recipeGrid');
+        if (recipeGrid) {
+            recipeGrid.innerHTML = '';
+        }
+        
+        // Re-enable virtual scrolling
+        if (state.virtualScroller) {
+            state.virtualScroller.enable();
+        } else {
+            // If virtual scroller doesn't exist, reinitialize it
+            setTimeout(() => {
+                initializeInfiniteScroll('recipes');
+            }, 100);
+        }
+    }
+    
+    renderDuplicateGroups() {
+        const recipeGrid = document.getElementById('recipeGrid');
+        if (!recipeGrid) return;
+        
+        // Clear existing content
+        recipeGrid.innerHTML = '';
+        
+        // Render each duplicate group
+        this.duplicateGroups.forEach((group, groupIndex) => {
+            const groupDiv = document.createElement('div');
+            groupDiv.className = 'duplicate-group';
+            groupDiv.dataset.fingerprint = group.fingerprint;
+            
+            // Create group header
+            const header = document.createElement('div');
+            header.className = 'duplicate-group-header';
+            header.innerHTML = `
+                <span>Duplicate Group #${groupIndex + 1} (${group.recipes.length} recipes)</span>
+                <span>
+                    <button class="btn-select-all" onclick="recipeManager.duplicatesManager.toggleSelectAllInGroup('${group.fingerprint}')">
+                        Select All
+                    </button>
+                    <button class="btn-select-latest" onclick="recipeManager.duplicatesManager.selectLatestInGroup('${group.fingerprint}')">
+                        Keep Latest
+                    </button>
+                </span>
+            `;
+            groupDiv.appendChild(header);
+            
+            // Create cards container
+            const cardsDiv = document.createElement('div');
+            cardsDiv.className = 'card-group-container';
+            
+            // Add scrollable class if there are many recipes in the group
+            if (group.recipes.length > 6) {
+                cardsDiv.classList.add('scrollable');
+                
+                // Add expand/collapse toggle button
+                const toggleBtn = document.createElement('button');
+                toggleBtn.className = 'group-toggle-btn';
+                toggleBtn.innerHTML = '<i class="fas fa-chevron-down"></i>';
+                toggleBtn.title = "Expand/Collapse";
+                toggleBtn.onclick = function() {
+                    cardsDiv.classList.toggle('scrollable');
+                    this.innerHTML = cardsDiv.classList.contains('scrollable') ? 
+                        '<i class="fas fa-chevron-down"></i>' : 
+                        '<i class="fas fa-chevron-up"></i>';
+                };
+                groupDiv.appendChild(toggleBtn);
+            }
+            
+            // Sort recipes by date (newest first)
+            const sortedRecipes = [...group.recipes].sort((a, b) => b.modified - a.modified);
+            
+            // Add all recipe cards in this group
+            sortedRecipes.forEach((recipe, index) => {
+                // Create recipe card
+                const recipeCard = new RecipeCard(recipe, (recipe) => {
+                    this.recipeManager.showRecipeDetails(recipe);
+                });
+                const card = recipeCard.element;
+                
+                // Add duplicate class
+                card.classList.add('duplicate');
+                
+                // Mark the latest one
+                if (index === 0) {
+                    card.classList.add('latest');
+                }
+                
+                // Add selection checkbox
+                const checkbox = document.createElement('input');
+                checkbox.type = 'checkbox';
+                checkbox.className = 'selector-checkbox';
+                checkbox.dataset.recipeId = recipe.id;
+                checkbox.dataset.groupFingerprint = group.fingerprint;
+                
+                // Check if already selected
+                if (this.selectedForDeletion.has(recipe.id)) {
+                    checkbox.checked = true;
+                    card.classList.add('duplicate-selected');
+                }
+                
+                // Add change event to checkbox
+                checkbox.addEventListener('change', (e) => {
+                    e.stopPropagation();
+                    this.toggleCardSelection(recipe.id, card, checkbox);
+                });
+                
+                // Make the entire card clickable for selection
+                card.addEventListener('click', (e) => {
+                    // Don't toggle if clicking on the checkbox directly or card actions
+                    if (e.target === checkbox || e.target.closest('.card-actions')) {
+                        return;
+                    }
+                    
+                    // Toggle checkbox state
+                    checkbox.checked = !checkbox.checked;
+                    this.toggleCardSelection(recipe.id, card, checkbox);
+                });
+                
+                card.appendChild(checkbox);
+                cardsDiv.appendChild(card);
+            });
+            
+            groupDiv.appendChild(cardsDiv);
+            recipeGrid.appendChild(groupDiv);
+        });
+    }
+    
+    // Helper method to toggle card selection state
+    toggleCardSelection(recipeId, card, checkbox) {
+        if (checkbox.checked) {
+            this.selectedForDeletion.add(recipeId);
+            card.classList.add('duplicate-selected');
+        } else {
+            this.selectedForDeletion.delete(recipeId);
+            card.classList.remove('duplicate-selected');
+        }
+        
+        this.updateSelectedCount();
+    }
+    
+    updateSelectedCount() {
+        const selectedCountEl = document.getElementById('selectedCount');
+        if (selectedCountEl) {
+            selectedCountEl.textContent = this.selectedForDeletion.size;
+        }
+        
+        // Update delete button state
+        const deleteBtn = document.querySelector('.btn-delete-selected');
+        if (deleteBtn) {
+            deleteBtn.disabled = this.selectedForDeletion.size === 0;
+            deleteBtn.classList.toggle('disabled', this.selectedForDeletion.size === 0);
+        }
+    }
+    
+    toggleSelectAllInGroup(fingerprint) {
+        const checkboxes = document.querySelectorAll(`.selector-checkbox[data-group-fingerprint="${fingerprint}"]`);
+        const allSelected = Array.from(checkboxes).every(checkbox => checkbox.checked);
+        
+        // If all are selected, deselect all; otherwise select all
+        checkboxes.forEach(checkbox => {
+            checkbox.checked = !allSelected;
+            const recipeId = checkbox.dataset.recipeId;
+            const card = checkbox.closest('.lora-card');
+            
+            if (!allSelected) {
+                this.selectedForDeletion.add(recipeId);
+                card.classList.add('duplicate-selected');
+            } else {
+                this.selectedForDeletion.delete(recipeId);
+                card.classList.remove('duplicate-selected');
+            }
+        });
+        
+        // Update the button text
+        const button = document.querySelector(`.duplicate-group[data-fingerprint="${fingerprint}"] .btn-select-all`);
+        if (button) {
+            button.textContent = !allSelected ? "Deselect All" : "Select All";
+        }
+        
+        this.updateSelectedCount();
+    }
+    
+    selectAllInGroup(fingerprint) {
+        const checkboxes = document.querySelectorAll(`.selector-checkbox[data-group-fingerprint="${fingerprint}"]`);
+        checkboxes.forEach(checkbox => {
+            checkbox.checked = true;
+            this.selectedForDeletion.add(checkbox.dataset.recipeId);
+            checkbox.closest('.lora-card').classList.add('duplicate-selected');
+        });
+        
+        // Update the button text
+        const button = document.querySelector(`.duplicate-group[data-fingerprint="${fingerprint}"] .btn-select-all`);
+        if (button) {
+            button.textContent = "Deselect All";
+        }
+        
+        this.updateSelectedCount();
+    }
+    
+    selectLatestInGroup(fingerprint) {
+        // Find all checkboxes in this group
+        const checkboxes = document.querySelectorAll(`.selector-checkbox[data-group-fingerprint="${fingerprint}"]`);
+        
+        // Get all the recipes in this group
+        const group = this.duplicateGroups.find(g => g.fingerprint === fingerprint);
+        if (!group) return;
+        
+        // Sort recipes by date (newest first)
+        const sortedRecipes = [...group.recipes].sort((a, b) => b.modified - a.modified);
+        
+        // Skip the first (latest) one and select the rest for deletion
+        for (let i = 1; i < sortedRecipes.length; i++) {
+            const recipeId = sortedRecipes[i].id;
+            const checkbox = document.querySelector(`.selector-checkbox[data-recipe-id="${recipeId}"]`);
+            
+            if (checkbox) {
+                checkbox.checked = true;
+                this.selectedForDeletion.add(recipeId);
+                checkbox.closest('.lora-card').classList.add('duplicate-selected');
+            }
+        }
+        
+        // Make sure the latest one is not selected
+        const latestId = sortedRecipes[0].id;
+        const latestCheckbox = document.querySelector(`.selector-checkbox[data-recipe-id="${latestId}"]`);
+        
+        if (latestCheckbox) {
+            latestCheckbox.checked = false;
+            this.selectedForDeletion.delete(latestId);
+            latestCheckbox.closest('.lora-card').classList.remove('duplicate-selected');
+        }
+        
+        this.updateSelectedCount();
+    }
+    
+    selectLatestDuplicates() {
+        // For each duplicate group, select all but the latest recipe
+        this.duplicateGroups.forEach(group => {
+            this.selectLatestInGroup(group.fingerprint);
+        });
+    }
+    
+    async deleteSelectedDuplicates() {
+        if (this.selectedForDeletion.size === 0) {
+            showToast('No recipes selected for deletion', 'info');
+            return;
+        }
+        
+        try {
+            // Show the delete confirmation modal instead of a simple confirm
+            const duplicateDeleteCount = document.getElementById('duplicateDeleteCount');
+            if (duplicateDeleteCount) {
+                duplicateDeleteCount.textContent = this.selectedForDeletion.size;
+            }
+            
+            // Use the modal manager to show the confirmation modal
+            modalManager.showModal('duplicateDeleteModal');
+        } catch (error) {
+            console.error('Error preparing delete:', error);
+            showToast('Error: ' + error.message, 'error');
+        }
+    }
+    
+    // Add new method to execute deletion after confirmation
+    async confirmDeleteDuplicates() {
+        try {
+            document.body.classList.add('loading');
+            
+            // Close the modal
+            modalManager.closeModal('duplicateDeleteModal');
+            
+            // Prepare recipe IDs for deletion
+            const recipeIds = Array.from(this.selectedForDeletion);
+            
+            // Call API to bulk delete
+            const response = await fetch('/api/recipes/bulk-delete', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ recipe_ids: recipeIds })
+            });
+            
+            if (!response.ok) {
+                throw new Error('Failed to delete selected recipes');
+            }
+            
+            const data = await response.json();
+            if (!data.success) {
+                throw new Error(data.error || 'Unknown error deleting recipes');
+            }
+            
+            showToast(`Successfully deleted ${data.total_deleted} recipes`, 'success');
+            
+            // Exit duplicate mode if deletions were successful
+            if (data.total_deleted > 0) {
+                this.exitDuplicateMode();
+            }
+            
+        } catch (error) {
+            console.error('Error deleting recipes:', error);
+            showToast('Failed to delete recipes: ' + error.message, 'error');
+        } finally {
+            document.body.classList.remove('loading');
+        }
+    }
+}

static/js/components/Header.js

@@ -78,5 +78,33 @@ export class HeaderManager {
           // Handle support panel logic
         });
       }
+
+      // Handle QR code toggle
+      const qrToggle = document.getElementById('toggleQRCode');
+      const qrContainer = document.getElementById('qrCodeContainer');
+      
+      if (qrToggle && qrContainer) {
+          qrToggle.addEventListener('click', function() {
+              qrContainer.classList.toggle('show');
+              qrToggle.classList.toggle('active');
+              
+              const toggleText = qrToggle.querySelector('.toggle-text');
+              if (qrContainer.classList.contains('show')) {
+                  toggleText.textContent = 'Hide WeChat QR Code';
+                  // Add small delay to ensure DOM is updated before scrolling
+                  setTimeout(() => {
+                      const supportModal = document.querySelector('.support-modal');
+                      if (supportModal) {
+                          supportModal.scrollTo({
+                              top: supportModal.scrollHeight,
+                              behavior: 'smooth'
+                          });
+                      }
+                  }, 250);
+              } else {
+                  toggleText.textContent = 'Show WeChat QR Code';
+              }
+          });
+      }
     }
 }

static/js/components/LoraCard.js

@@ -3,7 +3,183 @@ import { state } from '../state/index.js';
 import { showLoraModal } from './loraModal/index.js';
 import { bulkManager } from '../managers/BulkManager.js';
 import { NSFW_LEVELS } from '../utils/constants.js';
-import { replacePreview, deleteModel, saveModelMetadata } from '../api/loraApi.js'
+import { replacePreview, saveModelMetadata } from '../api/loraApi.js'
+import { showDeleteModal } from '../utils/modalUtils.js';
+
+// Add a global event delegation handler
+export function setupLoraCardEventDelegation() {
+    const gridElement = document.getElementById('loraGrid');
+    if (!gridElement) return;
+    
+    // Remove any existing event listener to prevent duplication
+    gridElement.removeEventListener('click', handleLoraCardEvent);
+    
+    // Add the event delegation handler
+    gridElement.addEventListener('click', handleLoraCardEvent);
+}
+
+// Event delegation handler for all lora card events
+function handleLoraCardEvent(event) {
+    // Find the closest card element
+    const card = event.target.closest('.lora-card');
+    if (!card) return;
+    
+    // Handle specific elements within the card
+    if (event.target.closest('.toggle-blur-btn')) {
+        event.stopPropagation();
+        toggleBlurContent(card);
+        return;
+    }
+    
+    if (event.target.closest('.show-content-btn')) {
+        event.stopPropagation();
+        showBlurredContent(card);
+        return;
+    }
+    
+    if (event.target.closest('.fa-star')) {
+        event.stopPropagation();
+        toggleFavorite(card);
+        return;
+    }
+    
+    if (event.target.closest('.fa-globe')) {
+        event.stopPropagation();
+        if (card.dataset.from_civitai === 'true') {
+            openCivitai(card.dataset.name);
+        }
+        return;
+    }
+    
+    if (event.target.closest('.fa-copy')) {
+        event.stopPropagation();
+        copyLoraCode(card);
+        return;
+    }
+    
+    if (event.target.closest('.fa-trash')) {
+        event.stopPropagation();
+        showDeleteModal(card.dataset.filepath);
+        return;
+    }
+    
+    if (event.target.closest('.fa-image')) {
+        event.stopPropagation();
+        replacePreview(card.dataset.filepath);
+        return;
+    }
+    
+    // If no specific element was clicked, handle the card click (show modal or toggle selection)
+    if (state.bulkMode) {
+        // Toggle selection using the bulk manager
+        bulkManager.toggleCardSelection(card);
+    } else {
+        // Normal behavior - show modal
+        const loraMeta = {
+            sha256: card.dataset.sha256,
+            file_path: card.dataset.filepath,
+            model_name: card.dataset.name,
+            file_name: card.dataset.file_name,
+            folder: card.dataset.folder,
+            modified: card.dataset.modified,
+            file_size: card.dataset.file_size,
+            from_civitai: card.dataset.from_civitai === 'true',
+            base_model: card.dataset.base_model,
+            usage_tips: card.dataset.usage_tips,
+            notes: card.dataset.notes,
+            favorite: card.dataset.favorite === 'true',
+            // Parse civitai metadata from the card's dataset
+            civitai: (() => {
+                try {
+                    // Attempt to parse the JSON string
+                    return JSON.parse(card.dataset.meta || '{}');
+                } catch (e) {
+                    console.error('Failed to parse civitai metadata:', e);
+                    return {}; // Return empty object on error
+                }
+            })(),
+            tags: JSON.parse(card.dataset.tags || '[]'),
+            modelDescription: card.dataset.modelDescription || ''
+        };
+        showLoraModal(loraMeta);
+    }
+}
+
+// Helper functions for event handling
+function toggleBlurContent(card) {
+    const preview = card.querySelector('.card-preview');
+    const isBlurred = preview.classList.toggle('blurred');
+    const icon = card.querySelector('.toggle-blur-btn i');
+    
+    // Update the icon based on blur state
+    if (isBlurred) {
+        icon.className = 'fas fa-eye';
+    } else {
+        icon.className = 'fas fa-eye-slash';
+    }
+    
+    // Toggle the overlay visibility
+    const overlay = card.querySelector('.nsfw-overlay');
+    if (overlay) {
+        overlay.style.display = isBlurred ? 'flex' : 'none';
+    }
+}
+
+function showBlurredContent(card) {
+    const preview = card.querySelector('.card-preview');
+    preview.classList.remove('blurred');
+    
+    // Update the toggle button icon
+    const toggleBtn = card.querySelector('.toggle-blur-btn');
+    if (toggleBtn) {
+        toggleBtn.querySelector('i').className = 'fas fa-eye-slash';
+    }
+    
+    // Hide the overlay
+    const overlay = card.querySelector('.nsfw-overlay');
+    if (overlay) {
+        overlay.style.display = 'none';
+    }
+}
+
+async function toggleFavorite(card) {
+    const starIcon = card.querySelector('.fa-star');
+    const isFavorite = starIcon.classList.contains('fas');
+    const newFavoriteState = !isFavorite;
+    
+    try {
+        // Save the new favorite state to the server
+        await saveModelMetadata(card.dataset.filepath, { 
+            favorite: newFavoriteState 
+        });
+
+        // Update the UI
+        if (newFavoriteState) {
+            starIcon.classList.remove('far');
+            starIcon.classList.add('fas', 'favorite-active');
+            starIcon.title = 'Remove from favorites';
+            card.dataset.favorite = 'true';
+            showToast('Added to favorites', 'success');
+        } else {
+            starIcon.classList.remove('fas', 'favorite-active');
+            starIcon.classList.add('far');
+            starIcon.title = 'Add to favorites';
+            card.dataset.favorite = 'false';
+            showToast('Removed from favorites', 'success');
+        }
+    } catch (error) {
+        console.error('Failed to update favorite status:', error);
+        showToast('Failed to update favorite status', 'error');
+    }
+}
+
+async function copyLoraCode(card) {
+    const usageTips = JSON.parse(card.dataset.usage_tips || '{}');
+    const strength = usageTips.strength || 1;
+    const loraSyntax = `<lora:${card.dataset.file_name}:${strength}>`;
+    
+    await copyToClipboard(loraSyntax, 'LoRA syntax copied');
+}
 
 export function createLoraCard(lora) {
     const card = document.createElement('div');
@@ -122,162 +298,12 @@ export function createLoraCard(lora) {
         </div>
     `;
 
-    // Main card click event - modified to handle bulk mode
-    card.addEventListener('click', () => {
-        // Check if we're in bulk mode
-        if (state.bulkMode) {
-            // Toggle selection using the bulk manager
-            bulkManager.toggleCardSelection(card);
-        } else {
-            // Normal behavior - show modal
-            const loraMeta = {
-                sha256: card.dataset.sha256,
-                file_path: card.dataset.filepath,
-                model_name: card.dataset.name,
-                file_name: card.dataset.file_name,
-                folder: card.dataset.folder,
-                modified: card.dataset.modified,
-                file_size: card.dataset.file_size,
-                from_civitai: card.dataset.from_civitai === 'true',
-                base_model: card.dataset.base_model,
-                usage_tips: card.dataset.usage_tips,
-                notes: card.dataset.notes,
-                favorite: card.dataset.favorite === 'true',
-                // Parse civitai metadata from the card's dataset
-                civitai: (() => {
-                    try {
-                        // Attempt to parse the JSON string
-                        return JSON.parse(card.dataset.meta || '{}');
-                    } catch (e) {
-                        console.error('Failed to parse civitai metadata:', e);
-                        return {}; // Return empty object on error
-                    }
-                })(),
-                tags: JSON.parse(card.dataset.tags || '[]'),
-                modelDescription: card.dataset.modelDescription || ''
-            };
-            showLoraModal(loraMeta);
-        }
-    });
-
-    // Toggle blur button functionality
-    const toggleBlurBtn = card.querySelector('.toggle-blur-btn');
-    if (toggleBlurBtn) {
-        toggleBlurBtn.addEventListener('click', (e) => {
-            e.stopPropagation();
-            const preview = card.querySelector('.card-preview');
-            const isBlurred = preview.classList.toggle('blurred');
-            const icon = toggleBlurBtn.querySelector('i');
-            
-            // Update the icon based on blur state
-            if (isBlurred) {
-                icon.className = 'fas fa-eye';
-            } else {
-                icon.className = 'fas fa-eye-slash';
-            }
-            
-            // Toggle the overlay visibility
-            const overlay = card.querySelector('.nsfw-overlay');
-            if (overlay) {
-                overlay.style.display = isBlurred ? 'flex' : 'none';
-            }
-        });
-    }
-
-    // Show content button functionality
-    const showContentBtn = card.querySelector('.show-content-btn');
-    if (showContentBtn) {
-        showContentBtn.addEventListener('click', (e) => {
-            e.stopPropagation();
-            const preview = card.querySelector('.card-preview');
-            preview.classList.remove('blurred');
-            
-            // Update the toggle button icon
-            const toggleBtn = card.querySelector('.toggle-blur-btn');
-            if (toggleBtn) {
-                toggleBtn.querySelector('i').className = 'fas fa-eye-slash';
-            }
-            
-            // Hide the overlay
-            const overlay = card.querySelector('.nsfw-overlay');
-            if (overlay) {
-                overlay.style.display = 'none';
-            }
-        });
-    }
-
-    // Favorite button click event
-    card.querySelector('.fa-star')?.addEventListener('click', async e => {
-        e.stopPropagation();
-        const starIcon = e.currentTarget;
-        const isFavorite = starIcon.classList.contains('fas');
-        const newFavoriteState = !isFavorite;
-        
-        try {
-            // Save the new favorite state to the server
-            await saveModelMetadata(card.dataset.filepath, { 
-                favorite: newFavoriteState 
-            });
-
-            // Update the UI
-            if (newFavoriteState) {
-                starIcon.classList.remove('far');
-                starIcon.classList.add('fas', 'favorite-active');
-                starIcon.title = 'Remove from favorites';
-                card.dataset.favorite = 'true';
-                showToast('Added to favorites', 'success');
-            } else {
-                starIcon.classList.remove('fas', 'favorite-active');
-                starIcon.classList.add('far');
-                starIcon.title = 'Add to favorites';
-                card.dataset.favorite = 'false';
-                showToast('Removed from favorites', 'success');
-            }
-        } catch (error) {
-            console.error('Failed to update favorite status:', error);
-            showToast('Failed to update favorite status', 'error');
-        }
-    });
-
-    // Copy button click event
-    card.querySelector('.fa-copy')?.addEventListener('click', async e => {
-        e.stopPropagation();
-        const usageTips = JSON.parse(card.dataset.usage_tips || '{}');
-        const strength = usageTips.strength || 1;
-        const loraSyntax = `<lora:${card.dataset.file_name}:${strength}>`;
-        
-        await copyToClipboard(loraSyntax, 'LoRA syntax copied');
-    });
-
-    // Civitai button click event
-    if (lora.from_civitai) {
-        card.querySelector('.fa-globe')?.addEventListener('click', e => {
-            e.stopPropagation();
-            openCivitai(lora.model_name);
-        });
-    }
-
-    // Delete button click event
-    card.querySelector('.fa-trash')?.addEventListener('click', e => {
-        e.stopPropagation();
-        deleteModel(lora.file_path);
-    });
-
-    // Replace preview button click event
-    card.querySelector('.fa-image')?.addEventListener('click', e => {
-        e.stopPropagation();
-        replacePreview(lora.file_path);
-    });
-    
-    // Apply bulk mode styling if currently in bulk mode
-    if (state.bulkMode) {
-        const actions = card.querySelectorAll('.card-actions');
-        actions.forEach(actionGroup => {
-            actionGroup.style.display = 'none';
-        });
+    // Add a special class for virtual scroll positioning if needed
+    if (state.virtualScroller) {
+        card.classList.add('virtual-scroll-item');
     }
     
-    // Add autoplayOnHover handlers for video elements if needed
+    // Add video auto-play on hover functionality if needed
     const videoElement = card.querySelector('video');
     if (videoElement && autoplayOnHover) {
         const cardPreview = card.querySelector('.card-preview');
@@ -286,15 +312,10 @@ export function createLoraCard(lora) {
         videoElement.removeAttribute('autoplay');
         videoElement.pause();
         
-        // Add mouse events to trigger play/pause
-        cardPreview.addEventListener('mouseenter', () => {
-            videoElement.play();
-        });
-        
-        cardPreview.addEventListener('mouseleave', () => {
-            videoElement.pause();
-            videoElement.currentTime = 0;
-        });
+        // Add mouse events to trigger play/pause using event attributes
+        // This approach reduces the number of event listeners created
+        cardPreview.setAttribute('onmouseenter', 'this.querySelector("video")?.play()');
+        cardPreview.setAttribute('onmouseleave', 'const v=this.querySelector("video"); if(v){v.pause();v.currentTime=0;}');
     }
 
     return card;
@@ -307,7 +328,7 @@ export function updateCardsForBulkMode(isBulkMode) {
     
     document.body.classList.toggle('bulk-mode', isBulkMode);
     
-    // Get all lora cards
+    // Get all lora cards - this can now be from the DOM or through the virtual scroller
     const loraCards = document.querySelectorAll('.lora-card');
     
     loraCards.forEach(card => {
@@ -329,6 +350,11 @@ export function updateCardsForBulkMode(isBulkMode) {
         }
     });
     
+    // If using virtual scroller, we need to rerender after toggling bulk mode
+    if (state.virtualScroller && typeof state.virtualScroller.scheduleRender === 'function') {
+        state.virtualScroller.scheduleRender();
+    }
+    
     // Apply selection state to cards if entering bulk mode
     if (isBulkMode) {
         bulkManager.applySelectionState();

static/js/components/RecipeCard.js

@@ -1,12 +1,16 @@
 // Recipe Card Component
 import { showToast, copyToClipboard } from '../utils/uiHelpers.js';
 import { modalManager } from '../managers/ModalManager.js';
+import { getCurrentPageState } from '../state/index.js';
 
 class RecipeCard {
     constructor(recipe, clickHandler) {
         this.recipe = recipe;
         this.clickHandler = clickHandler;
         this.element = this.createCardElement();
+        
+        // Store reference to this instance on the DOM element for updates
+        this.element._recipeCardInstance = this;
     }
     
     createCardElement() {
@@ -33,10 +37,15 @@ class RecipeCard {
                          (this.recipe.file_path ? `/loras_static/root1/preview/${this.recipe.file_path.split('/').pop()}` : 
                          '/loras_static/images/no-preview.png');
 
+        // Check if in duplicates mode
+        const pageState = getCurrentPageState();
+        const isDuplicatesMode = pageState.duplicatesMode;
+
         card.innerHTML = `
-            <div class="recipe-indicator" title="Recipe">R</div>
+            ${!isDuplicatesMode ? `<div class="recipe-indicator" title="Recipe">R</div>` : ''}
             <div class="card-preview">
                 <img src="${imageUrl}" alt="${this.recipe.title}">
+                ${!isDuplicatesMode ? `
                 <div class="card-header">
                     <div class="base-model-wrapper">
                         ${baseModel ? `<span class="base-model-label" title="${baseModel}">${baseModel}</span>` : ''}
@@ -47,19 +56,22 @@ class RecipeCard {
                         <i class="fas fa-trash" title="Delete Recipe"></i>
                     </div>
                 </div>
+                ` : ''}
                 <div class="card-footer">
                     <div class="model-info">
                         <span class="model-name">${this.recipe.title}</span>
                     </div>
+                    ${!isDuplicatesMode ? `
                     <div class="lora-count ${allLorasAvailable ? 'ready' : (lorasCount > 0 ? 'missing' : '')}" 
                          title="${this.getLoraStatusTitle(lorasCount, missingLorasCount)}">
                         <i class="fas fa-layer-group"></i> ${lorasCount}
                     </div>
+                    ` : ''}
                 </div>
             </div>
         `;
         
-        this.attachEventListeners(card);
+        this.attachEventListeners(card, isDuplicatesMode);
         return card;
     }
     
@@ -69,29 +81,31 @@ class RecipeCard {
         return `${missingCount} of ${totalCount} LoRAs missing`;
     }
     
-    attachEventListeners(card) {
-        // Recipe card click event
-        card.addEventListener('click', () => {
-            this.clickHandler(this.recipe);
-        });
-        
-        // Share button click event - prevent propagation to card
-        card.querySelector('.fa-share-alt')?.addEventListener('click', (e) => {
-            e.stopPropagation();
-            this.shareRecipe();
-        });
-        
-        // Copy button click event - prevent propagation to card
-        card.querySelector('.fa-copy')?.addEventListener('click', (e) => {
-            e.stopPropagation();
-            this.copyRecipeSyntax();
-        });
-        
-        // Delete button click event - prevent propagation to card
-        card.querySelector('.fa-trash')?.addEventListener('click', (e) => {
-            e.stopPropagation();
-            this.showDeleteConfirmation();
-        });
+    attachEventListeners(card, isDuplicatesMode) {
+        // Recipe card click event - only attach if not in duplicates mode
+        if (!isDuplicatesMode) {
+            card.addEventListener('click', () => {
+                this.clickHandler(this.recipe);
+            });
+            
+            // Share button click event - prevent propagation to card
+            card.querySelector('.fa-share-alt')?.addEventListener('click', (e) => {
+                e.stopPropagation();
+                this.shareRecipe();
+            });
+            
+            // Copy button click event - prevent propagation to card
+            card.querySelector('.fa-copy')?.addEventListener('click', (e) => {
+                e.stopPropagation();
+                this.copyRecipeSyntax();
+            });
+            
+            // Delete button click event - prevent propagation to card
+            card.querySelector('.fa-trash')?.addEventListener('click', (e) => {
+                e.stopPropagation();
+                this.showDeleteConfirmation();
+            });
+        }
     }
     
     copyRecipeSyntax() {

static/js/components/RecipeModal.js

@@ -2,6 +2,7 @@
 import { showToast, copyToClipboard } from '../utils/uiHelpers.js';
 import { state } from '../state/index.js';
 import { setSessionItem, removeSessionItem } from '../utils/storageHelpers.js';
+import { updateRecipeCard } from '../utils/cardUpdater.js';
 
 class RecipeModal {
     constructor() {
@@ -82,7 +83,7 @@ class RecipeModal {
     
     showRecipeDetails(recipe) {
         // Store the full recipe for editing
-        this.currentRecipe = JSON.parse(JSON.stringify(recipe)); // 深拷贝以避免对原始对象的修改
+        this.currentRecipe = recipe;
         
         // Set modal title with edit icon
         const modalTitle = document.getElementById('recipeModalTitle');
@@ -245,6 +246,45 @@ class RecipeModal {
                 imgElement.alt = recipe.title || 'Recipe Preview';
                 mediaContainer.appendChild(imgElement);
             }
+
+            // Add source URL container if the recipe has a source_path
+            const sourceUrlContainer = document.createElement('div');
+            sourceUrlContainer.className = 'source-url-container';
+            const hasSourceUrl = recipe.source_path && recipe.source_path.trim().length > 0;
+            const sourceUrl = hasSourceUrl ? recipe.source_path : '';
+            const isValidUrl = hasSourceUrl && (sourceUrl.startsWith('http://') || sourceUrl.startsWith('https://'));
+            
+            sourceUrlContainer.innerHTML = `
+                <div class="source-url-content">
+                    <span class="source-url-icon"><i class="fas fa-link"></i></span>
+                    <span class="source-url-text" title="${isValidUrl ? 'Click to open source URL' : 'No valid URL'}">${
+                        hasSourceUrl ? sourceUrl : 'No source URL'
+                    }</span>
+                </div>
+                <button class="source-url-edit-btn" title="Edit source URL">
+                    <i class="fas fa-pencil-alt"></i>
+                </button>
+            `;
+            
+            // Add source URL editor
+            const sourceUrlEditor = document.createElement('div');
+            sourceUrlEditor.className = 'source-url-editor';
+            sourceUrlEditor.innerHTML = `
+                <input type="text" class="source-url-input" placeholder="Enter source URL (e.g., https://civitai.com/...)" value="${sourceUrl}">
+                <div class="source-url-actions">
+                    <button class="source-url-cancel-btn">Cancel</button>
+                    <button class="source-url-save-btn">Save</button>
+                </div>
+            `;
+            
+            // Append both containers to the media container
+            mediaContainer.appendChild(sourceUrlContainer);
+            mediaContainer.appendChild(sourceUrlEditor);
+            
+            // Set up event listeners for source URL functionality
+            setTimeout(() => {
+                this.setupSourceUrlHandlers();
+            }, 50);
         }
         
         // Set generation parameters
@@ -451,8 +491,6 @@ class RecipeModal {
             lorasListElement.innerHTML = '<div class="no-loras">No LoRAs associated with this recipe</div>';
             this.recipeLorasSyntax = '';
         }
-
-        console.log(this.currentRecipe.loras);
         
         // Show the modal
         modalManager.showModal('recipeModal');
@@ -648,50 +686,8 @@ class RecipeModal {
                 // 更新当前recipe对象的属性
                 Object.assign(this.currentRecipe, updates);
                 
-                // 确保这个更新也传播到卡片视图
-                // 尝试找到可能显示这个recipe的卡片并更新它
-                try {
-                    const recipeCards = document.querySelectorAll('.recipe-card');
-                    recipeCards.forEach(card => {
-                        if (card.dataset.recipeId === this.recipeId) {
-                            // 更新卡片标题
-                            if (updates.title) {
-                                const titleElement = card.querySelector('.recipe-title');
-                                if (titleElement) {
-                                    titleElement.textContent = updates.title;
-                                }
-                            }
-                            
-                            // 更新卡片标签
-                            if (updates.tags) {
-                                const tagsElement = card.querySelector('.recipe-tags');
-                                if (tagsElement) {
-                                    if (updates.tags.length > 0) {
-                                        tagsElement.innerHTML = updates.tags.map(
-                                            tag => `<div class="recipe-tag">${tag}</div>`
-                                        ).join('');
-                                    } else {
-                                        tagsElement.innerHTML = '';
-                                    }
-                                }
-                            }
-                        }
-                    });
-                } catch (err) {
-                    console.log("Non-critical error updating recipe cards:", err);
-                }
-                
-                // 重要：强制刷新recipes列表，确保从服务器获取最新数据
-                try {
-                    if (window.recipeManager && typeof window.recipeManager.loadRecipes === 'function') {
-                        // 异步刷新recipes列表，不阻塞用户界面
-                        setTimeout(() => {
-                            window.recipeManager.loadRecipes(true);
-                        }, 500);
-                    }
-                } catch (err) {
-                    console.log("Error refreshing recipes list:", err);
-                }
+                // Update the recipe card in the UI
+                updateRecipeCard(this.recipeId, updates);
             } else {
                 showToast(`Failed to update recipe: ${data.error}`, 'error');
             }
@@ -951,8 +947,8 @@ class RecipeModal {
             let loraSyntaxMatch = inputValue.match(/<lora:([^:>]+)(?::[^>]+)?>/);
             let fileName = loraSyntaxMatch ? loraSyntaxMatch[1] : inputValue.trim();
             
-            // Remove any file extension if present
-            fileName = fileName.replace(/\.\w+$/, '');
+            // Remove .safetensors extension if present
+            fileName = fileName.replace(/\.safetensors$/, '');
             
             // Get the deleted lora data
             const deletedLora = this.currentRecipe.loras[loraIndex];
@@ -1069,6 +1065,56 @@ class RecipeModal {
             });
         });
     }
+
+    // New method to set up source URL handlers
+    setupSourceUrlHandlers() {
+        const sourceUrlContainer = document.querySelector('.source-url-container');
+        const sourceUrlEditor = document.querySelector('.source-url-editor');
+        const sourceUrlText = sourceUrlContainer.querySelector('.source-url-text');
+        const sourceUrlEditBtn = sourceUrlContainer.querySelector('.source-url-edit-btn');
+        const sourceUrlCancelBtn = sourceUrlEditor.querySelector('.source-url-cancel-btn');
+        const sourceUrlSaveBtn = sourceUrlEditor.querySelector('.source-url-save-btn');
+        const sourceUrlInput = sourceUrlEditor.querySelector('.source-url-input');
+        
+        // Show editor on edit button click
+        sourceUrlEditBtn.addEventListener('click', () => {
+            sourceUrlContainer.classList.add('hide');
+            sourceUrlEditor.classList.add('active');
+            sourceUrlInput.focus();
+        });
+        
+        // Cancel editing
+        sourceUrlCancelBtn.addEventListener('click', () => {
+            sourceUrlEditor.classList.remove('active');
+            sourceUrlContainer.classList.remove('hide');
+            sourceUrlInput.value = this.currentRecipe.source_path || '';
+        });
+        
+        // Save new source URL
+        sourceUrlSaveBtn.addEventListener('click', () => {
+            const newSourceUrl = sourceUrlInput.value.trim();
+            if (newSourceUrl && newSourceUrl !== this.currentRecipe.source_path) {
+                // Update source URL in the UI
+                sourceUrlText.textContent = newSourceUrl;
+                sourceUrlText.title = newSourceUrl.startsWith('http://') || newSourceUrl.startsWith('https://') ? 'Click to open source URL' : 'No valid URL';
+                
+                // Update the recipe on the server
+                this.updateRecipeMetadata({ source_path: newSourceUrl });
+            }
+            
+            // Hide editor
+            sourceUrlEditor.classList.remove('active');
+            sourceUrlContainer.classList.remove('hide');
+        });
+        
+        // Open source URL in a new tab if it's valid
+        sourceUrlText.addEventListener('click', () => {
+            const url = sourceUrlText.textContent.trim();
+            if (url.startsWith('http://') || url.startsWith('https://')) {
+                window.open(url, '_blank');
+            }
+        });
+    }
 }
 
 export { RecipeModal };

static/js/components/alphabet/AlphabetBar.js

@@ -0,0 +1,319 @@
+// AlphabetBar.js - Component for alphabet filtering
+import { getCurrentPageState, setCurrentPageType } from '../../state/index.js';
+import { getStorageItem, setStorageItem } from '../../utils/storageHelpers.js';
+import { resetAndReload } from '../../api/loraApi.js';
+
+/**
+ * AlphabetBar class - Handles the alphabet filtering UI and interactions
+ */
+export class AlphabetBar {
+    constructor(pageType = 'loras') {
+        // Store the page type
+        this.pageType = pageType;
+        
+        // Get the current page state
+        this.pageState = getCurrentPageState();
+        
+        // Initialize letter counts
+        this.letterCounts = {};
+        
+        // Initialize the component
+        this.initializeComponent();
+    }
+    
+    /**
+     * Initialize the alphabet bar component
+     */
+    async initializeComponent() {
+        // Get letter counts from API
+        await this.fetchLetterCounts();
+        
+        // Initialize event listeners
+        this.initEventListeners();
+        
+        // Restore the active letter filter from storage if available
+        this.restoreActiveLetterFilter();
+        
+        // Restore collapse state from storage
+        this.restoreCollapseState();
+
+        // Update the toggle button indicator if there's an active letter filter
+        this.updateToggleIndicator();
+    }
+    
+    /**
+     * Fetch letter counts from the API
+     */
+    async fetchLetterCounts() {
+        try {
+            const response = await fetch('/api/loras/letter-counts');
+            
+            if (!response.ok) {
+                throw new Error(`Failed to fetch letter counts: ${response.statusText}`);
+            }
+            
+            const data = await response.json();
+            
+            if (data.success && data.letter_counts) {
+                this.letterCounts = data.letter_counts;
+                
+                // Update the count display in the UI
+                this.updateLetterCountsDisplay();
+            }
+        } catch (error) {
+            console.error('Error fetching letter counts:', error);
+        }
+    }
+    
+    /**
+     * Update the letter counts display in the UI
+     */
+    updateLetterCountsDisplay() {
+        const letterChips = document.querySelectorAll('.letter-chip');
+        
+        letterChips.forEach(chip => {
+            const letter = chip.dataset.letter;
+            const count = this.letterCounts[letter] || 0;
+            
+            // Update the title attribute for tooltip display
+            if (count > 0) {
+                chip.title = `${letter}: ${count} LoRAs`;
+                chip.classList.remove('disabled');
+            } else {
+                chip.title = `${letter}: No LoRAs`;
+                chip.classList.add('disabled');
+            }
+            
+            // Keep the count span for backward compatibility
+            const countSpan = chip.querySelector('.count');
+            if (countSpan) {
+                countSpan.textContent = ` (${count})`;
+            }
+        });
+    }
+    
+    /**
+     * Initialize event listeners for the alphabet bar
+     */
+    initEventListeners() {
+        const alphabetBar = document.querySelector('.alphabet-bar');
+        const toggleButton = document.querySelector('.toggle-alphabet-bar');
+        const alphabetBarContainer = document.querySelector('.alphabet-bar-container');
+        
+        if (alphabetBar) {
+            // Use event delegation for letter chips
+            alphabetBar.addEventListener('click', (e) => {
+                const letterChip = e.target.closest('.letter-chip');
+                
+                if (letterChip && !letterChip.classList.contains('disabled')) {
+                    this.handleLetterClick(letterChip);
+                }
+            });
+            
+            // Add toggle button listener
+            if (toggleButton && alphabetBarContainer) {
+                toggleButton.addEventListener('click', () => {
+                    alphabetBarContainer.classList.toggle('collapsed');
+                    
+                    // If expanding and there's an active letter, scroll it into view
+                    if (!alphabetBarContainer.classList.contains('collapsed')) {
+                        this.scrollActiveLetterIntoView();
+                    }
+                    
+                    // Save collapse state to storage
+                    setStorageItem(`${this.pageType}_alphabetBarCollapsed`, 
+                        alphabetBarContainer.classList.contains('collapsed'));
+
+                    // Update toggle indicator
+                    this.updateToggleIndicator();
+                });
+            }
+            
+            // Add keyboard shortcut listeners
+            document.addEventListener('keydown', (e) => {
+                // Alt + letter shortcuts
+                if (e.altKey && !e.ctrlKey && !e.metaKey) {
+                    const key = e.key.toUpperCase();
+                    
+                    // Check if it's a letter A-Z
+                    if (/^[A-Z]$/.test(key)) {
+                        const letterChip = document.querySelector(`.letter-chip[data-letter="${key}"]`);
+                        
+                        if (letterChip && !letterChip.classList.contains('disabled')) {
+                            this.handleLetterClick(letterChip);
+                            e.preventDefault();
+                        }
+                    } 
+                    // Special cases for non-letter filters
+                    else if (e.key === '0' || e.key === ')') {
+                        // Alt+0 for numbers (#)
+                        const letterChip = document.querySelector('.letter-chip[data-letter="#"]');
+                        
+                        if (letterChip && !letterChip.classList.contains('disabled')) {
+                            this.handleLetterClick(letterChip);
+                            e.preventDefault();
+                        }
+                    } else if (e.key === '2' || e.key === '@') {
+                        // Alt+@ for special characters
+                        const letterChip = document.querySelector('.letter-chip[data-letter="@"]');
+                        
+                        if (letterChip && !letterChip.classList.contains('disabled')) {
+                            this.handleLetterClick(letterChip);
+                            e.preventDefault();
+                        }
+                    } else if (e.key === 'c' || e.key === 'C') {
+                        // Alt+C for CJK characters
+                        const letterChip = document.querySelector('.letter-chip[data-letter="漢"]');
+                        
+                        if (letterChip && !letterChip.classList.contains('disabled')) {
+                            this.handleLetterClick(letterChip);
+                            e.preventDefault();
+                        }
+                    }
+                }
+            });
+        }
+    }
+    
+    /**
+     * Restore the collapse state from storage
+     */
+    restoreCollapseState() {
+        const alphabetBarContainer = document.querySelector('.alphabet-bar-container');
+        
+        if (alphabetBarContainer) {
+            const isCollapsed = getStorageItem(`${this.pageType}_alphabetBarCollapsed`);
+            
+            // If there's a stored preference, apply it
+            if (isCollapsed !== null) {
+                if (isCollapsed) {
+                    alphabetBarContainer.classList.add('collapsed');
+                } else {
+                    alphabetBarContainer.classList.remove('collapsed');
+                }
+            }
+        }
+    }
+    
+    /**
+     * Handle letter chip click
+     * @param {HTMLElement} letterChip - The letter chip that was clicked
+     */
+    handleLetterClick(letterChip) {
+        const letter = letterChip.dataset.letter;
+        const wasActive = letterChip.classList.contains('active');
+        
+        // Remove active class from all letter chips
+        document.querySelectorAll('.letter-chip').forEach(chip => {
+            chip.classList.remove('active');
+        });
+        
+        if (!wasActive) {
+            // Set the new active letter
+            letterChip.classList.add('active');
+            this.pageState.activeLetterFilter = letter;
+            
+            // Save to storage
+            setStorageItem(`${this.pageType}_activeLetterFilter`, letter);
+        } else {
+            // Clear the active letter filter
+            this.pageState.activeLetterFilter = null;
+            
+            // Remove from storage
+            setStorageItem(`${this.pageType}_activeLetterFilter`, null);
+        }
+        
+        // Update visual indicator on toggle button
+        this.updateToggleIndicator();
+        
+        // Trigger a reload with the new filter
+        resetAndReload(true);
+    }
+    
+    /**
+     * Restore the active letter filter from storage
+     */
+    restoreActiveLetterFilter() {
+        const activeLetterFilter = getStorageItem(`${this.pageType}_activeLetterFilter`);
+        
+        if (activeLetterFilter) {
+            const letterChip = document.querySelector(`.letter-chip[data-letter="${activeLetterFilter}"]`);
+            
+            if (letterChip && !letterChip.classList.contains('disabled')) {
+                letterChip.classList.add('active');
+                this.pageState.activeLetterFilter = activeLetterFilter;
+                
+                // Scroll the active letter into view if the alphabet bar is expanded
+                this.scrollActiveLetterIntoView();
+            }
+        }
+    }
+    
+    /**
+     * Clear the active letter filter
+     */
+    clearActiveLetterFilter() {
+        // Remove active class from all letter chips
+        document.querySelectorAll('.letter-chip').forEach(chip => {
+            chip.classList.remove('active');
+        });
+        
+        // Clear the active letter filter
+        this.pageState.activeLetterFilter = null;
+        
+        // Remove from storage
+        setStorageItem(`${this.pageType}_activeLetterFilter`, null);
+        
+        // Update the toggle button indicator
+        this.updateToggleIndicator();
+    }
+    
+    /**
+     * Update letter counts with new data
+     * @param {Object} newCounts - New letter count data
+     */
+    updateCounts(newCounts) {
+        this.letterCounts = { ...newCounts };
+        this.updateLetterCountsDisplay();
+    }
+    
+    /**
+     * Update the toggle button visual indicator based on active filter
+     */
+    updateToggleIndicator() {
+        const toggleButton = document.querySelector('.toggle-alphabet-bar');
+        const hasActiveFilter = this.pageState.activeLetterFilter !== null;
+        
+        if (toggleButton) {
+            if (hasActiveFilter) {
+                toggleButton.classList.add('has-active-letter');
+            } else {
+                toggleButton.classList.remove('has-active-letter');
+            }
+        }
+    }
+    
+    /**
+     * Scroll the active letter into view if the alphabet bar is expanded
+     */
+    scrollActiveLetterIntoView() {
+        if (!this.pageState.activeLetterFilter) return;
+
+        
+        const alphabetBarContainer = document.querySelector('.alphabet-bar-container');
+        if (alphabetBarContainer) {
+            const activeLetterChip = document.querySelector(`.letter-chip.active`);
+            
+            if (activeLetterChip) {
+                // Use a small timeout to ensure the alphabet bar is fully expanded
+                setTimeout(() => {
+                    activeLetterChip.scrollIntoView({
+                        behavior: 'smooth',
+                        block: 'center',
+                        inline: 'center'
+                    });
+                }, 300);
+            }
+        }
+    }
+}

static/js/components/alphabet/index.js

@@ -0,0 +1,14 @@
+// Alphabet component index file
+import { AlphabetBar } from './AlphabetBar.js';
+
+// Export the class
+export { AlphabetBar };
+
+/**
+ * Factory function to create the appropriate alphabet bar
+ * @param {string} pageType - The type of page ('loras' or 'checkpoints')
+ * @returns {AlphabetBar} - The alphabet bar instance
+ */
+export function createAlphabetBar(pageType) {
+    return new AlphabetBar(pageType);
+}

static/js/components/checkpointModal/ModelMetadata.js

@@ -171,12 +171,13 @@ export function setupBaseModelEditing(filePath) {
             'Stable Diffusion 2.x': [BASE_MODELS.SD_2_0, BASE_MODELS.SD_2_1],
             'Stable Diffusion 3.x': [BASE_MODELS.SD_3, BASE_MODELS.SD_3_5, BASE_MODELS.SD_3_5_MEDIUM, BASE_MODELS.SD_3_5_LARGE, BASE_MODELS.SD_3_5_LARGE_TURBO],
             'SDXL': [BASE_MODELS.SDXL, BASE_MODELS.SDXL_LIGHTNING, BASE_MODELS.SDXL_HYPER],
-            'Video Models': [BASE_MODELS.SVD, BASE_MODELS.WAN_VIDEO, BASE_MODELS.HUNYUAN_VIDEO],
+            'Video Models': [BASE_MODELS.SVD, BASE_MODELS.LTXV, BASE_MODELS.WAN_VIDEO, BASE_MODELS.HUNYUAN_VIDEO],
             'Other Models': [
                 BASE_MODELS.FLUX_1_D, BASE_MODELS.FLUX_1_S, BASE_MODELS.AURAFLOW,
                 BASE_MODELS.PIXART_A, BASE_MODELS.PIXART_E, BASE_MODELS.HUNYUAN_1,
                 BASE_MODELS.LUMINA, BASE_MODELS.KOLORS, BASE_MODELS.NOOBAI,
-                BASE_MODELS.ILLUSTRIOUS, BASE_MODELS.PONY, BASE_MODELS.UNKNOWN
+                BASE_MODELS.ILLUSTRIOUS, BASE_MODELS.PONY, BASE_MODELS.HIDREAM,
+                BASE_MODELS.UNKNOWN
             ]
         };
         

static/js/components/checkpointModal/ShowcaseView.js

@@ -322,8 +322,72 @@ function initMetadataPanelHandlers(container) {
     const mediaWrappers = container.querySelectorAll('.media-wrapper');
     
     mediaWrappers.forEach(wrapper => {
+        // Get the metadata panel and media element (img or video)
         const metadataPanel = wrapper.querySelector('.image-metadata-panel');
-        if (!metadataPanel) return;
+        const mediaElement = wrapper.querySelector('img, video');
+        
+        if (!metadataPanel || !mediaElement) return;
+        
+        let isOverMetadataPanel = false;
+        
+        // Add event listeners to the wrapper for mouse tracking
+        wrapper.addEventListener('mousemove', (e) => {
+            // Get mouse position relative to wrapper
+            const rect = wrapper.getBoundingClientRect();
+            const mouseX = e.clientX - rect.left;
+            const mouseY = e.clientY - rect.top;
+            
+            // Get the actual displayed dimensions of the media element
+            const mediaRect = getRenderedMediaRect(mediaElement, rect.width, rect.height);
+            
+            // Check if mouse is over the actual media content
+            const isOverMedia = (
+                mouseX >= mediaRect.left && 
+                mouseX <= mediaRect.right && 
+                mouseY >= mediaRect.top && 
+                mouseY <= mediaRect.bottom
+            );
+            
+            // Show metadata panel when over media content or metadata panel itself
+            if (isOverMedia || isOverMetadataPanel) {
+                metadataPanel.classList.add('visible');
+            } else {
+                metadataPanel.classList.remove('visible');
+            }
+        });
+        
+        wrapper.addEventListener('mouseleave', () => {
+            // Only hide panel when mouse leaves the wrapper and not over the metadata panel
+            if (!isOverMetadataPanel) {
+                metadataPanel.classList.remove('visible');
+            }
+        });
+        
+        // Add mouse enter/leave events for the metadata panel itself
+        metadataPanel.addEventListener('mouseenter', () => {
+            isOverMetadataPanel = true;
+            metadataPanel.classList.add('visible');
+        });
+        
+        metadataPanel.addEventListener('mouseleave', () => {
+            isOverMetadataPanel = false;
+            // Only hide if mouse is not over the media
+            const rect = wrapper.getBoundingClientRect();
+            const mediaRect = getRenderedMediaRect(mediaElement, rect.width, rect.height);
+            const mouseX = event.clientX - rect.left;
+            const mouseY = event.clientY - rect.top;
+            
+            const isOverMedia = (
+                mouseX >= mediaRect.left && 
+                mouseX <= mediaRect.right && 
+                mouseY >= mediaRect.top && 
+                mouseY <= mediaRect.bottom
+            );
+            
+            if (!isOverMedia) {
+                metadataPanel.classList.remove('visible');
+            }
+        });
         
         // Prevent events from bubbling
         metadataPanel.addEventListener('click', (e) => {
@@ -352,11 +416,61 @@ function initMetadataPanelHandlers(container) {
         
         // Prevent panel scroll from causing modal scroll
         metadataPanel.addEventListener('wheel', (e) => {
-            e.stopPropagation();
-        });
+            const isAtTop = metadataPanel.scrollTop === 0;
+            const isAtBottom = metadataPanel.scrollHeight - metadataPanel.scrollTop === metadataPanel.clientHeight;
+            
+            // Only prevent default if scrolling would cause the panel to scroll
+            if ((e.deltaY < 0 && !isAtTop) || (e.deltaY > 0 && !isAtBottom)) {
+                e.stopPropagation();
+            }
+        }, { passive: true });
     });
 }
 
+/**
+ * Get the actual rendered rectangle of a media element with object-fit: contain
+ * @param {HTMLElement} mediaElement - The img or video element
+ * @param {number} containerWidth - Width of the container
+ * @param {number} containerHeight - Height of the container
+ * @returns {Object} - Rect with left, top, right, bottom coordinates
+ */
+function getRenderedMediaRect(mediaElement, containerWidth, containerHeight) {
+    // Get natural dimensions of the media
+    const naturalWidth = mediaElement.naturalWidth || mediaElement.videoWidth || mediaElement.clientWidth;
+    const naturalHeight = mediaElement.naturalHeight || mediaElement.videoHeight || mediaElement.clientHeight;
+    
+    if (!naturalWidth || !naturalHeight) {
+        // Fallback if dimensions cannot be determined
+        return { left: 0, top: 0, right: containerWidth, bottom: containerHeight };
+    }
+    
+    // Calculate aspect ratios
+    const containerRatio = containerWidth / containerHeight;
+    const mediaRatio = naturalWidth / naturalHeight;
+    
+    let renderedWidth, renderedHeight, left = 0, top = 0;
+    
+    // Apply object-fit: contain logic
+    if (containerRatio > mediaRatio) {
+        // Container is wider than media - will have empty space on sides
+        renderedHeight = containerHeight;
+        renderedWidth = renderedHeight * mediaRatio;
+        left = (containerWidth - renderedWidth) / 2;
+    } else {
+        // Container is taller than media - will have empty space top/bottom
+        renderedWidth = containerWidth;
+        renderedHeight = renderedWidth / mediaRatio;
+        top = (containerHeight - renderedHeight) / 2;
+    }
+    
+    return {
+        left,
+        top,
+        right: left + renderedWidth,
+        bottom: top + renderedHeight
+    };
+}
+
 /**
  * Initialize blur toggle handlers
  */

static/js/components/controls/LorasControls.js

@@ -2,6 +2,7 @@
 import { PageControls } from './PageControls.js';
 import { loadMoreLoras, fetchCivitai, resetAndReload, refreshLoras } from '../../api/loraApi.js';
 import { getSessionItem, removeSessionItem } from '../../utils/storageHelpers.js';
+import { createAlphabetBar } from '../alphabet/index.js';
 
 /**
  * LorasControls class - Extends PageControls for LoRA-specific functionality
@@ -16,6 +17,9 @@ export class LorasControls extends PageControls {
         
         // Check for custom filters (e.g., from recipe navigation)
         this.checkCustomFilters();
+        
+        // Initialize alphabet bar component
+        this.initAlphabetBar();
     }
     
     /**
@@ -142,4 +146,15 @@ export class LorasControls extends PageControls {
     _truncateText(text, maxLength) {
         return text.length > maxLength ? text.substring(0, maxLength - 3) + '...' : text;
     }
+    
+    /**
+     * Initialize the alphabet bar component
+     */
+    initAlphabetBar() {
+        // Create the alphabet bar component
+        this.alphabetBar = createAlphabetBar('loras');
+        
+        // Expose the alphabet bar to the global scope for debugging
+        window.alphabetBar = this.alphabetBar;
+    }
 }

static/js/components/controls/PageControls.js

@@ -37,7 +37,7 @@ export class PageControls {
      */
     initializeState() {
         // Set default values
-        this.pageState.pageSize = 20; 
+        this.pageState.pageSize = 100;
         this.pageState.isLoading = false;
         this.pageState.hasMore = true;
         

static/js/components/controls/index.js

@@ -2,6 +2,7 @@
 import { PageControls } from './PageControls.js';
 import { LorasControls } from './LorasControls.js';
 import { CheckpointsControls } from './CheckpointsControls.js';
+import { refreshVirtualScroll } from '../../utils/infiniteScroll.js';
 
 // Export the classes
 export { PageControls, LorasControls, CheckpointsControls };
@@ -20,4 +21,17 @@ export function createPageControls(pageType) {
         console.error(`Unknown page type: ${pageType}`);
         return null;
     }
+}
+
+// Example for a filter method:
+function applyFilter(filterType, value) {
+    // ...existing filter logic...
+    
+    // After filters are applied, refresh the virtual scroll if it exists
+    if (state.virtualScroller) {
+        refreshVirtualScroll();
+    } else {
+        // Fall back to existing reset and reload logic
+        resetAndReload(true);
+    }
 }

static/js/components/loraModal/ModelMetadata.js

@@ -173,12 +173,13 @@ export function setupBaseModelEditing(filePath) {
             'Stable Diffusion 2.x': [BASE_MODELS.SD_2_0, BASE_MODELS.SD_2_1],
             'Stable Diffusion 3.x': [BASE_MODELS.SD_3, BASE_MODELS.SD_3_5, BASE_MODELS.SD_3_5_MEDIUM, BASE_MODELS.SD_3_5_LARGE, BASE_MODELS.SD_3_5_LARGE_TURBO],
             'SDXL': [BASE_MODELS.SDXL, BASE_MODELS.SDXL_LIGHTNING, BASE_MODELS.SDXL_HYPER],
-            'Video Models': [BASE_MODELS.SVD, BASE_MODELS.WAN_VIDEO, BASE_MODELS.HUNYUAN_VIDEO],
+            'Video Models': [BASE_MODELS.SVD, BASE_MODELS.LTXV, BASE_MODELS.WAN_VIDEO, BASE_MODELS.HUNYUAN_VIDEO],
             'Other Models': [
                 BASE_MODELS.FLUX_1_D, BASE_MODELS.FLUX_1_S, BASE_MODELS.AURAFLOW,
                 BASE_MODELS.PIXART_A, BASE_MODELS.PIXART_E, BASE_MODELS.HUNYUAN_1,
                 BASE_MODELS.LUMINA, BASE_MODELS.KOLORS, BASE_MODELS.NOOBAI,
-                BASE_MODELS.ILLUSTRIOUS, BASE_MODELS.PONY, BASE_MODELS.UNKNOWN
+                BASE_MODELS.ILLUSTRIOUS, BASE_MODELS.PONY, BASE_MODELS.HIDREAM,
+                BASE_MODELS.UNKNOWN
             ]
         };
         

static/js/components/loraModal/ShowcaseView.js

@@ -329,9 +329,72 @@ function initMetadataPanelHandlers(container) {
     const mediaWrappers = container.querySelectorAll('.media-wrapper');
     
     mediaWrappers.forEach(wrapper => {
-        // Get the metadata panel
+        // Get the metadata panel and media element (img or video)
         const metadataPanel = wrapper.querySelector('.image-metadata-panel');
-        if (!metadataPanel) return;
+        const mediaElement = wrapper.querySelector('img, video');
+        
+        if (!metadataPanel || !mediaElement) return;
+        
+        let isOverMetadataPanel = false;
+        
+        // Add event listeners to the wrapper for mouse tracking
+        wrapper.addEventListener('mousemove', (e) => {
+            // Get mouse position relative to wrapper
+            const rect = wrapper.getBoundingClientRect();
+            const mouseX = e.clientX - rect.left;
+            const mouseY = e.clientY - rect.top;
+            
+            // Get the actual displayed dimensions of the media element
+            const mediaRect = getRenderedMediaRect(mediaElement, rect.width, rect.height);
+            
+            // Check if mouse is over the actual media content
+            const isOverMedia = (
+                mouseX >= mediaRect.left && 
+                mouseX <= mediaRect.right && 
+                mouseY >= mediaRect.top && 
+                mouseY <= mediaRect.bottom
+            );
+            
+            // Show metadata panel when over media content
+            if (isOverMedia || isOverMetadataPanel) {
+                metadataPanel.classList.add('visible');
+            } else {
+                metadataPanel.classList.remove('visible');
+            }
+        });
+        
+        wrapper.addEventListener('mouseleave', () => {
+            // Only hide panel when mouse leaves the wrapper and not over the metadata panel
+            if (!isOverMetadataPanel) {
+                metadataPanel.classList.remove('visible');
+            }
+        });
+        
+        // Add mouse enter/leave events for the metadata panel itself
+        metadataPanel.addEventListener('mouseenter', () => {
+            isOverMetadataPanel = true;
+            metadataPanel.classList.add('visible');
+        });
+        
+        metadataPanel.addEventListener('mouseleave', () => {
+            isOverMetadataPanel = false;
+            // Only hide if mouse is not over the media
+            const rect = wrapper.getBoundingClientRect();
+            const mediaRect = getRenderedMediaRect(mediaElement, rect.width, rect.height);
+            const mouseX = event.clientX - rect.left;
+            const mouseY = event.clientY - rect.top;
+            
+            const isOverMedia = (
+                mouseX >= mediaRect.left && 
+                mouseX <= mediaRect.right && 
+                mouseY >= mediaRect.top && 
+                mouseY <= mediaRect.bottom
+            );
+            
+            if (!isOverMedia) {
+                metadataPanel.classList.remove('visible');
+            }
+        });
         
         // Prevent events from the metadata panel from bubbling
         metadataPanel.addEventListener('click', (e) => {
@@ -371,6 +434,50 @@ function initMetadataPanelHandlers(container) {
     });
 }
 
+/**
+ * Get the actual rendered rectangle of a media element with object-fit: contain
+ * @param {HTMLElement} mediaElement - The img or video element
+ * @param {number} containerWidth - Width of the container
+ * @param {number} containerHeight - Height of the container
+ * @returns {Object} - Rect with left, top, right, bottom coordinates
+ */
+function getRenderedMediaRect(mediaElement, containerWidth, containerHeight) {
+    // Get natural dimensions of the media
+    const naturalWidth = mediaElement.naturalWidth || mediaElement.videoWidth || mediaElement.clientWidth;
+    const naturalHeight = mediaElement.naturalHeight || mediaElement.videoHeight || mediaElement.clientHeight;
+    
+    if (!naturalWidth || !naturalHeight) {
+        // Fallback if dimensions cannot be determined
+        return { left: 0, top: 0, right: containerWidth, bottom: containerHeight };
+    }
+    
+    // Calculate aspect ratios
+    const containerRatio = containerWidth / containerHeight;
+    const mediaRatio = naturalWidth / naturalHeight;
+    
+    let renderedWidth, renderedHeight, left = 0, top = 0;
+    
+    // Apply object-fit: contain logic
+    if (containerRatio > mediaRatio) {
+        // Container is wider than media - will have empty space on sides
+        renderedHeight = containerHeight;
+        renderedWidth = renderedHeight * mediaRatio;
+        left = (containerWidth - renderedWidth) / 2;
+    } else {
+        // Container is taller than media - will have empty space top/bottom
+        renderedWidth = containerWidth;
+        renderedHeight = renderedWidth / mediaRatio;
+        top = (containerHeight - renderedHeight) / 2;
+    }
+    
+    return {
+        left,
+        top,
+        right: left + renderedWidth,
+        bottom: top + renderedHeight
+    };
+}
+
 /**
  * 初始化模糊切换处理
  */

static/js/core.js

@@ -9,6 +9,7 @@ import { exampleImagesManager } from './managers/ExampleImagesManager.js';
 import { showToast, initTheme, initBackToTop, lazyLoadImages } from './utils/uiHelpers.js';
 import { initializeInfiniteScroll } from './utils/infiniteScroll.js';
 import { migrateStorageItems } from './utils/storageHelpers.js';
+import { setupLoraCardEventDelegation } from './components/LoraCard.js';
 
 // Core application class
 export class AppCore {
@@ -63,7 +64,12 @@ export class AppCore {
         // Initialize lazy loading for images on all pages
         lazyLoadImages();
         
-        // Initialize infinite scroll for pages that need it
+        // Setup event delegation for lora cards if on the loras page
+        if (pageType === 'loras') {
+            setupLoraCardEventDelegation();
+        }
+        
+        // Initialize virtual scroll for pages that need it
         if (['loras', 'recipes', 'checkpoints'].includes(pageType)) {
             initializeInfiniteScroll(pageType);
         }

static/js/loras.js

@@ -8,7 +8,7 @@ import { DownloadManager } from './managers/DownloadManager.js';
 import { moveManager } from './managers/MoveManager.js';
 import { LoraContextMenu } from './components/ContextMenu/index.js';
 import { createPageControls } from './components/controls/index.js';
-import { confirmDelete, closeDeleteModal } from './utils/modalUtils.js';
+import { confirmDelete, closeDeleteModal, confirmExclude, closeExcludeModal } from './utils/modalUtils.js';
 
 // Initialize the LoRA page
 class LoraPageManager {
@@ -35,6 +35,8 @@ class LoraPageManager {
         window.showLoraModal = showLoraModal;
         window.confirmDelete = confirmDelete;
         window.closeDeleteModal = closeDeleteModal;
+        window.confirmExclude = confirmExclude;
+        window.closeExcludeModal = closeExcludeModal;
         window.downloadManager = this.downloadManager;
         window.moveManager = moveManager;
         window.toggleShowcase = toggleShowcase;
@@ -61,8 +63,14 @@ class LoraPageManager {
         // Initialize the bulk manager
         bulkManager.initialize();
         
-        // Initialize common page features (lazy loading, infinite scroll)
+        // Initialize common page features (virtual scroll)
         appCore.initializePageFeatures();
+        
+        // Add virtual scroll class to grid for CSS adjustments
+        const loraGrid = document.getElementById('loraGrid');
+        if (loraGrid && state.virtualScroller) {
+            loraGrid.classList.add('virtual-scroll');
+        }
     }
 }
 

static/js/managers/ModalManager.js

@@ -59,6 +59,19 @@ export class ModalManager {
                 }
             });
         }
+        
+        // Add excludeModal registration
+        const excludeModal = document.getElementById('excludeModal');
+        if (excludeModal) {
+            this.registerModal('excludeModal', {
+                element: excludeModal,
+                onClose: () => {
+                    this.getModal('excludeModal').element.classList.remove('show');
+                    document.body.classList.remove('modal-open');
+                },
+                closeOnOutsideClick: true
+            });
+        }
 
         // Add downloadModal registration
         const downloadModal = document.getElementById('downloadModal');
@@ -145,6 +158,18 @@ export class ModalManager {
             });
         }
 
+        // Add duplicateDeleteModal registration
+        const duplicateDeleteModal = document.getElementById('duplicateDeleteModal');
+        if (duplicateDeleteModal) {
+            this.registerModal('duplicateDeleteModal', {
+                element: duplicateDeleteModal,
+                onClose: () => {
+                    this.getModal('duplicateDeleteModal').element.classList.remove('show');
+                    document.body.classList.remove('modal-open');
+                }
+            });
+        }
+        
         // Set up event listeners for modal toggles
         const supportToggle = document.getElementById('supportToggleBtn');
         if (supportToggle) {
@@ -208,7 +233,7 @@ export class ModalManager {
         // Store current scroll position before showing modal
         this.scrollPosition = window.scrollY;
 
-        if (id === 'deleteModal') {
+        if (id === 'deleteModal' || id === 'excludeModal' || id === 'duplicateDeleteModal') {
             modal.element.classList.add('show');
         } else {
             modal.element.style.display = 'block';

static/js/managers/SettingsManager.js

@@ -26,6 +26,11 @@ export class SettingsManager {
         if (savedSettings) {
             state.global.settings = { ...state.global.settings, ...savedSettings };
         }
+        
+        // Initialize default values for new settings if they don't exist
+        if (state.global.settings.compactMode === undefined) {
+            state.global.settings.compactMode = false;
+        }
     }
 
     initialize() {
@@ -76,6 +81,12 @@ export class SettingsManager {
         if (autoplayOnHoverCheckbox) {
             autoplayOnHoverCheckbox.checked = state.global.settings.autoplayOnHover || false;
         }
+        
+        // Set compact mode setting
+        const compactModeCheckbox = document.getElementById('compactMode');
+        if (compactModeCheckbox) {
+            compactModeCheckbox.checked = state.global.settings.compactMode || false;
+        }
 
         // Load default lora root
         await this.loadLoraRoots();
@@ -149,6 +160,8 @@ export class SettingsManager {
             state.global.settings.autoplayOnHover = value;
         } else if (settingKey === 'optimize_example_images') {
             state.global.settings.optimizeExampleImages = value;
+        } else if (settingKey === 'compact_mode') {
+            state.global.settings.compactMode = value;
         } else {
             // For any other settings that might be added in the future
             state.global.settings[settingKey] = value;
@@ -185,6 +198,12 @@ export class SettingsManager {
                 this.reloadContent();
             }
             
+            // Recalculate layout when compact mode changes
+            if (settingKey === 'compact_mode' && state.virtualScroller) {
+                state.virtualScroller.calculateLayout();
+                showToast(`Compact Mode ${value ? 'enabled' : 'disabled'}`, 'success');
+            }
+            
         } catch (error) {
             showToast('Failed to save setting: ' + error.message, 'error');
         }

static/js/managers/import/DownloadManager.js

@@ -0,0 +1,256 @@
+import { showToast } from '../../utils/uiHelpers.js';
+
+export class DownloadManager {
+    constructor(importManager) {
+        this.importManager = importManager;
+    }
+
+    async saveRecipe() {
+        // Check if we're in download-only mode (for existing recipe)
+        const isDownloadOnly = !!this.importManager.recipeId;
+        
+        if (!isDownloadOnly && !this.importManager.recipeName) {
+            showToast('Please enter a recipe name', 'error');
+            return;
+        }
+        
+        try {
+            // Show progress indicator
+            this.importManager.loadingManager.showSimpleLoading(isDownloadOnly ? 'Downloading LoRAs...' : 'Saving recipe...');
+            
+            // Only send the complete recipe to save if not in download-only mode
+            if (!isDownloadOnly) {
+                // Create FormData object for saving recipe
+                const formData = new FormData();
+                
+                // Add image data - depends on import mode
+                if (this.importManager.recipeImage) {
+                    // Direct upload
+                    formData.append('image', this.importManager.recipeImage);
+                } else if (this.importManager.recipeData && this.importManager.recipeData.image_base64) {
+                    // URL mode with base64 data
+                    formData.append('image_base64', this.importManager.recipeData.image_base64);
+                } else if (this.importManager.importMode === 'url') {
+                    // Fallback for URL mode - tell backend to fetch the image again
+                    const urlInput = document.getElementById('imageUrlInput');
+                    if (urlInput && urlInput.value) {
+                        formData.append('image_url', urlInput.value);
+                    } else {
+                        throw new Error('No image data available');
+                    }
+                } else {
+                    throw new Error('No image data available');
+                }
+                
+                formData.append('name', this.importManager.recipeName);
+                formData.append('tags', JSON.stringify(this.importManager.recipeTags));
+                
+                // Prepare complete metadata including generation parameters
+                const completeMetadata = {
+                    base_model: this.importManager.recipeData.base_model || "",
+                    loras: this.importManager.recipeData.loras || [],
+                    gen_params: this.importManager.recipeData.gen_params || {},
+                    raw_metadata: this.importManager.recipeData.raw_metadata || {}
+                };
+                
+                // Add source_path to metadata to track where the recipe was imported from
+                if (this.importManager.importMode === 'url') {
+                    const urlInput = document.getElementById('imageUrlInput');
+                    if (urlInput && urlInput.value) {
+                        completeMetadata.source_path = urlInput.value;
+                    }
+                }
+                
+                formData.append('metadata', JSON.stringify(completeMetadata));
+            
+                // Send save request
+                const response = await fetch('/api/recipes/save', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                const result = await response.json();
+
+                if (!result.success) {
+                    // Handle save error
+                    console.error("Failed to save recipe:", result.error);
+                    showToast(result.error, 'error');
+                    // Close modal
+                    modalManager.closeModal('importModal');
+                    return;
+                }
+            }
+
+            // Check if we need to download LoRAs
+            let failedDownloads = 0;
+            if (this.importManager.downloadableLoRAs && this.importManager.downloadableLoRAs.length > 0) {
+                await this.downloadMissingLoras();
+            }
+
+            // Show success message
+            if (isDownloadOnly) {
+                if (failedDownloads === 0) {    
+                    showToast('LoRAs downloaded successfully', 'success');
+                }
+            } else {
+                showToast(`Recipe "${this.importManager.recipeName}" saved successfully`, 'success');
+            }
+            
+            // Close modal
+            modalManager.closeModal('importModal');
+            
+            // Refresh the recipe
+            window.recipeManager.loadRecipes();
+            
+        } catch (error) {
+            console.error('Error:', error);
+            showToast(error.message, 'error');
+        } finally {
+            this.importManager.loadingManager.hide();
+        }
+    }
+
+    async downloadMissingLoras() {
+        // For download, we need to validate the target path
+        const loraRoot = document.getElementById('importLoraRoot')?.value;
+        if (!loraRoot) {
+            throw new Error('Please select a LoRA root directory');
+        }
+        
+        // Build target path
+        let targetPath = loraRoot;
+        if (this.importManager.selectedFolder) {
+            targetPath += '/' + this.importManager.selectedFolder;
+        }
+        
+        const newFolder = document.getElementById('importNewFolder')?.value?.trim();
+        if (newFolder) {
+            targetPath += '/' + newFolder;
+        }
+        
+        // Set up WebSocket for progress updates
+        const wsProtocol = window.location.protocol === 'https:' ? 'wss://' : 'ws://';
+        const ws = new WebSocket(`${wsProtocol}${window.location.host}/ws/fetch-progress`);
+        
+        // Show enhanced loading with progress details for multiple items
+        const updateProgress = this.importManager.loadingManager.showDownloadProgress(
+            this.importManager.downloadableLoRAs.length
+        );
+        
+        let completedDownloads = 0;
+        let failedDownloads = 0;
+        let accessFailures = 0;
+        let currentLoraProgress = 0;
+        
+        // Set up progress tracking for current download
+        ws.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            if (data.status === 'progress') {
+                // Update current LoRA progress
+                currentLoraProgress = data.progress;
+                
+                // Get current LoRA name
+                const currentLora = this.importManager.downloadableLoRAs[completedDownloads + failedDownloads];
+                const loraName = currentLora ? currentLora.name : '';
+                
+                // Update progress display
+                updateProgress(currentLoraProgress, completedDownloads, loraName);
+                
+                // Add more detailed status messages based on progress
+                if (currentLoraProgress < 3) {
+                    this.importManager.loadingManager.setStatus(
+                        `Preparing download for LoRA ${completedDownloads + failedDownloads + 1}/${this.importManager.downloadableLoRAs.length}`
+                    );
+                } else if (currentLoraProgress === 3) {
+                    this.importManager.loadingManager.setStatus(
+                        `Downloaded preview for LoRA ${completedDownloads + failedDownloads + 1}/${this.importManager.downloadableLoRAs.length}`
+                    );
+                } else if (currentLoraProgress > 3 && currentLoraProgress < 100) {
+                    this.importManager.loadingManager.setStatus(
+                        `Downloading LoRA ${completedDownloads + failedDownloads + 1}/${this.importManager.downloadableLoRAs.length}`
+                    );
+                } else {
+                    this.importManager.loadingManager.setStatus(
+                        `Finalizing LoRA ${completedDownloads + failedDownloads + 1}/${this.importManager.downloadableLoRAs.length}`
+                    );
+                }
+            }
+        };
+        
+        for (let i = 0; i < this.importManager.downloadableLoRAs.length; i++) {
+            const lora = this.importManager.downloadableLoRAs[i];
+            
+            // Reset current LoRA progress for new download
+            currentLoraProgress = 0;
+            
+            // Initial status update for new LoRA
+            this.importManager.loadingManager.setStatus(`Starting download for LoRA ${i+1}/${this.importManager.downloadableLoRAs.length}`);
+            updateProgress(0, completedDownloads, lora.name);
+            
+            try {
+                // Download the LoRA
+                const response = await fetch('/api/download-lora', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        download_url: lora.downloadUrl,
+                        model_version_id: lora.modelVersionId,
+                        model_hash: lora.hash,
+                        lora_root: loraRoot,
+                        relative_path: targetPath.replace(loraRoot + '/', '')
+                    })
+                });
+                
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    console.error(`Failed to download LoRA ${lora.name}: ${errorText}`);
+                    
+                    // Check if this is an early access error (status 401 is the key indicator)
+                    if (response.status === 401) {
+                        accessFailures++;
+                        this.importManager.loadingManager.setStatus(
+                            `Failed to download ${lora.name}: Access restricted`
+                        );
+                    }
+                    
+                    failedDownloads++;
+                    // Continue with next download
+                } else {
+                    completedDownloads++;
+                    
+                    // Update progress to show completion of current LoRA
+                    updateProgress(100, completedDownloads, '');
+                    
+                    if (completedDownloads + failedDownloads < this.importManager.downloadableLoRAs.length) {
+                        this.importManager.loadingManager.setStatus(
+                            `Completed ${completedDownloads}/${this.importManager.downloadableLoRAs.length} LoRAs. Starting next download...`
+                        );
+                    }
+                }
+            } catch (downloadError) {
+                console.error(`Error downloading LoRA ${lora.name}:`, downloadError);
+                failedDownloads++;
+                // Continue with next download
+            }
+        }
+        
+        // Close WebSocket
+        ws.close();
+        
+        // Show appropriate completion message based on results
+        if (failedDownloads === 0) {
+            showToast(`All ${completedDownloads} LoRAs downloaded successfully`, 'success');
+        } else {
+            if (accessFailures > 0) {
+                showToast(
+                    `Downloaded ${completedDownloads} of ${this.importManager.downloadableLoRAs.length} LoRAs. ${accessFailures} failed due to access restrictions. Check your API key in settings or early access status.`,
+                    'error'
+                );
+            } else {
+                showToast(`Downloaded ${completedDownloads} of ${this.importManager.downloadableLoRAs.length} LoRAs`, 'error');
+            }
+        }
+        
+        return failedDownloads;
+    }
+}

static/js/managers/import/FolderBrowser.js

@@ -0,0 +1,220 @@
+import { showToast } from '../../utils/uiHelpers.js';
+import { getStorageItem } from '../../utils/storageHelpers.js';
+
+export class FolderBrowser {
+    constructor(importManager) {
+        this.importManager = importManager;
+        this.folderClickHandler = null;
+        this.updateTargetPath = this.updateTargetPath.bind(this);
+    }
+
+    async proceedToLocation() {
+        // Show the location step with special handling
+        this.importManager.stepManager.showStep('locationStep');
+        
+        // Double-check after a short delay to ensure the step is visible
+        setTimeout(() => {
+            const locationStep = document.getElementById('locationStep');
+            if (locationStep.style.display !== 'block' || 
+                window.getComputedStyle(locationStep).display !== 'block') {
+                // Force display again
+                locationStep.style.display = 'block';
+                
+                // If still not visible, try with injected style
+                if (window.getComputedStyle(locationStep).display !== 'block') {
+                    this.importManager.stepManager.injectedStyles = document.createElement('style');
+                    this.importManager.stepManager.injectedStyles.innerHTML = `
+                        #locationStep {
+                            display: block !important;
+                            opacity: 1 !important;
+                            visibility: visible !important;
+                        }
+                    `;
+                    document.head.appendChild(this.importManager.stepManager.injectedStyles);
+                }
+            }
+        }, 100);
+        
+        try {
+            // Display missing LoRAs that will be downloaded
+            const missingLorasList = document.getElementById('missingLorasList');
+            if (missingLorasList && this.importManager.downloadableLoRAs.length > 0) {
+                // Calculate total size
+                const totalSize = this.importManager.downloadableLoRAs.reduce((sum, lora) => {
+                    return sum + (lora.size ? parseInt(lora.size) : 0);
+                }, 0);
+                
+                // Update total size display
+                const totalSizeDisplay = document.getElementById('totalDownloadSize');
+                if (totalSizeDisplay) {
+                    totalSizeDisplay.textContent = this.importManager.formatFileSize(totalSize);
+                }
+                
+                // Update header to include count of missing LoRAs
+                const missingLorasHeader = document.querySelector('.summary-header h3');
+                if (missingLorasHeader) {
+                    missingLorasHeader.innerHTML = `Missing LoRAs <span class="lora-count-badge">(${this.importManager.downloadableLoRAs.length})</span> <span id="totalDownloadSize" class="total-size-badge">${this.importManager.formatFileSize(totalSize)}</span>`;
+                }
+                
+                // Generate missing LoRAs list
+                missingLorasList.innerHTML = this.importManager.downloadableLoRAs.map(lora => {
+                    const sizeDisplay = lora.size ? 
+                        this.importManager.formatFileSize(lora.size) : 'Unknown size';
+                    const baseModel = lora.baseModel ? 
+                        `<span class="lora-base-model">${lora.baseModel}</span>` : '';
+                    const isEarlyAccess = lora.isEarlyAccess;
+                    
+                    // Early access badge
+                    let earlyAccessBadge = '';
+                    if (isEarlyAccess) {
+                        earlyAccessBadge = `<span class="early-access-badge">
+                            <i class="fas fa-clock"></i> Early Access
+                        </span>`;
+                    }
+                    
+                    return `
+                        <div class="missing-lora-item ${isEarlyAccess ? 'is-early-access' : ''}">
+                            <div class="missing-lora-info">
+                                <div class="missing-lora-name">${lora.name}</div>
+                                ${baseModel}
+                                ${earlyAccessBadge}
+                            </div>
+                            <div class="missing-lora-size">${sizeDisplay}</div>
+                        </div>
+                    `;
+                }).join('');
+                
+                // Set up toggle for missing LoRAs list
+                const toggleBtn = document.getElementById('toggleMissingLorasList');
+                if (toggleBtn) {
+                    toggleBtn.addEventListener('click', () => {
+                        missingLorasList.classList.toggle('collapsed');
+                        const icon = toggleBtn.querySelector('i');
+                        if (icon) {
+                            icon.classList.toggle('fa-chevron-down');
+                            icon.classList.toggle('fa-chevron-up');
+                        }
+                    });
+                }
+            }
+            
+            // Fetch LoRA roots
+            const rootsResponse = await fetch('/api/lora-roots');
+            if (!rootsResponse.ok) {
+                throw new Error(`Failed to fetch LoRA roots: ${rootsResponse.status}`);
+            }
+            
+            const rootsData = await rootsResponse.json();
+            const loraRoot = document.getElementById('importLoraRoot');
+            if (loraRoot) {
+                loraRoot.innerHTML = rootsData.roots.map(root => 
+                    `<option value="${root}">${root}</option>`
+                ).join('');
+                
+                // Set default lora root if available
+                const defaultRoot = getStorageItem('settings', {}).default_loras_root;
+                if (defaultRoot && rootsData.roots.includes(defaultRoot)) {
+                    loraRoot.value = defaultRoot;
+                }
+            }
+            
+            // Fetch folders
+            const foldersResponse = await fetch('/api/folders');
+            if (!foldersResponse.ok) {
+                throw new Error(`Failed to fetch folders: ${foldersResponse.status}`);
+            }
+            
+            const foldersData = await foldersResponse.json();
+            const folderBrowser = document.getElementById('importFolderBrowser');
+            if (folderBrowser) {
+                folderBrowser.innerHTML = foldersData.folders.map(folder => 
+                    folder ? `<div class="folder-item" data-folder="${folder}">${folder}</div>` : ''
+                ).join('');
+            }
+
+            // Initialize folder browser after loading data
+            this.initializeFolderBrowser();
+        } catch (error) {
+            console.error('Error in API calls:', error);
+            showToast(error.message, 'error');
+        }
+    }
+
+    initializeFolderBrowser() {
+        const folderBrowser = document.getElementById('importFolderBrowser');
+        if (!folderBrowser) return;
+
+        // Cleanup existing handler if any
+        this.cleanup();
+
+        // Create new handler
+        this.folderClickHandler = (event) => {
+            const folderItem = event.target.closest('.folder-item');
+            if (!folderItem) return;
+
+            if (folderItem.classList.contains('selected')) {
+                folderItem.classList.remove('selected');
+                this.importManager.selectedFolder = '';
+            } else {
+                folderBrowser.querySelectorAll('.folder-item').forEach(f => 
+                    f.classList.remove('selected'));
+                folderItem.classList.add('selected');
+                this.importManager.selectedFolder = folderItem.dataset.folder;
+            }
+            
+            // Update path display after folder selection
+            this.updateTargetPath();
+        };
+
+        // Add the new handler
+        folderBrowser.addEventListener('click', this.folderClickHandler);
+        
+        // Add event listeners for path updates
+        const loraRoot = document.getElementById('importLoraRoot');
+        const newFolder = document.getElementById('importNewFolder');
+        
+        if (loraRoot) loraRoot.addEventListener('change', this.updateTargetPath);
+        if (newFolder) newFolder.addEventListener('input', this.updateTargetPath);
+        
+        // Update initial path
+        this.updateTargetPath();
+    }
+
+    cleanup() {
+        if (this.folderClickHandler) {
+            const folderBrowser = document.getElementById('importFolderBrowser');
+            if (folderBrowser) {
+                folderBrowser.removeEventListener('click', this.folderClickHandler);
+                this.folderClickHandler = null;
+            }
+        }
+        
+        // Remove path update listeners
+        const loraRoot = document.getElementById('importLoraRoot');
+        const newFolder = document.getElementById('importNewFolder');
+        
+        if (loraRoot) loraRoot.removeEventListener('change', this.updateTargetPath);
+        if (newFolder) newFolder.removeEventListener('input', this.updateTargetPath);
+    }
+    
+    updateTargetPath() {
+        const pathDisplay = document.getElementById('importTargetPathDisplay');
+        if (!pathDisplay) return;
+        
+        const loraRoot = document.getElementById('importLoraRoot')?.value || '';
+        const newFolder = document.getElementById('importNewFolder')?.value?.trim() || '';
+        
+        let fullPath = loraRoot || 'Select a LoRA root directory'; 
+        
+        if (loraRoot) {
+            if (this.importManager.selectedFolder) {
+                fullPath += '/' + this.importManager.selectedFolder;
+            }
+            if (newFolder) {
+                fullPath += '/' + newFolder;
+            }
+        }
+    
+        pathDisplay.innerHTML = `<span class="path-text">${fullPath}</span>`;
+    }
+}

static/js/managers/import/ImageProcessor.js

@@ -0,0 +1,208 @@
+import { showToast } from '../../utils/uiHelpers.js';
+
+export class ImageProcessor {
+    constructor(importManager) {
+        this.importManager = importManager;
+    }
+
+    handleFileUpload(event) {
+        const file = event.target.files[0];
+        const errorElement = document.getElementById('uploadError');
+        
+        if (!file) return;
+        
+        // Validate file type
+        if (!file.type.match('image.*')) {
+            errorElement.textContent = 'Please select an image file';
+            return;
+        }
+        
+        // Reset error
+        errorElement.textContent = '';
+        this.importManager.recipeImage = file;
+        
+        // Auto-proceed to next step if file is selected
+        this.importManager.uploadAndAnalyzeImage();
+    }
+
+    async handleUrlInput() {
+        const urlInput = document.getElementById('imageUrlInput');
+        const errorElement = document.getElementById('urlError');
+        const input = urlInput.value.trim();
+        
+        // Validate input
+        if (!input) {
+            errorElement.textContent = 'Please enter a URL or file path';
+            return;
+        }
+        
+        // Reset error
+        errorElement.textContent = '';
+        
+        // Show loading indicator
+        this.importManager.loadingManager.showSimpleLoading('Processing input...');
+        
+        try {
+            // Check if it's a URL or a local file path
+            if (input.startsWith('http://') || input.startsWith('https://')) {
+                // Handle as URL
+                await this.analyzeImageFromUrl(input);
+            } else {
+                // Handle as local file path
+                await this.analyzeImageFromLocalPath(input);
+            }
+        } catch (error) {
+            errorElement.textContent = error.message || 'Failed to process input';
+        } finally {
+            this.importManager.loadingManager.hide();
+        }
+    }
+
+    async analyzeImageFromUrl(url) {
+        try {
+            // Call the API with URL data
+            const response = await fetch('/api/recipes/analyze-image', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ url: url })
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.error || 'Failed to analyze image from URL');
+            }
+            
+            // Get recipe data from response
+            this.importManager.recipeData = await response.json();
+            
+            // Check if we have an error message
+            if (this.importManager.recipeData.error) {
+                throw new Error(this.importManager.recipeData.error);
+            }
+            
+            // Check if we have valid recipe data
+            if (!this.importManager.recipeData || 
+                !this.importManager.recipeData.loras || 
+                this.importManager.recipeData.loras.length === 0) {
+                throw new Error('No LoRA information found in this image');
+            }
+            
+            // Find missing LoRAs
+            this.importManager.missingLoras = this.importManager.recipeData.loras.filter(
+                lora => !lora.existsLocally
+            );
+            
+            // Reset import as new flag
+            this.importManager.importAsNew = false;
+            
+            // Proceed to recipe details step
+            this.importManager.showRecipeDetailsStep();
+            
+        } catch (error) {
+            console.error('Error analyzing URL:', error);
+            throw error;
+        }
+    }
+
+    async analyzeImageFromLocalPath(path) {
+        try {
+            // Call the API with local path data
+            const response = await fetch('/api/recipes/analyze-local-image', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ path: path })
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.error || 'Failed to load image from local path');
+            }
+            
+            // Get recipe data from response
+            this.importManager.recipeData = await response.json();
+            
+            // Check if we have an error message
+            if (this.importManager.recipeData.error) {
+                throw new Error(this.importManager.recipeData.error);
+            }
+            
+            // Check if we have valid recipe data
+            if (!this.importManager.recipeData || 
+                !this.importManager.recipeData.loras || 
+                this.importManager.recipeData.loras.length === 0) {
+                throw new Error('No LoRA information found in this image');
+            }
+            
+            // Find missing LoRAs
+            this.importManager.missingLoras = this.importManager.recipeData.loras.filter(
+                lora => !lora.existsLocally
+            );
+            
+            // Reset import as new flag
+            this.importManager.importAsNew = false;
+            
+            // Proceed to recipe details step
+            this.importManager.showRecipeDetailsStep();
+            
+        } catch (error) {
+            console.error('Error analyzing local path:', error);
+            throw error;
+        }
+    }
+
+    async uploadAndAnalyzeImage() {
+        if (!this.importManager.recipeImage) {
+            showToast('Please select an image first', 'error');
+            return;
+        }
+        
+        try {
+            this.importManager.loadingManager.showSimpleLoading('Analyzing image metadata...');
+            
+            // Create form data for upload
+            const formData = new FormData();
+            formData.append('image', this.importManager.recipeImage);
+            
+            // Upload image for analysis
+            const response = await fetch('/api/recipes/analyze-image', {
+                method: 'POST',
+                body: formData
+            });
+             
+            // Get recipe data from response
+            this.importManager.recipeData = await response.json();
+
+            // Check if we have an error message
+            if (this.importManager.recipeData.error) {
+                throw new Error(this.importManager.recipeData.error);
+            }
+            
+            // Check if we have valid recipe data
+            if (!this.importManager.recipeData || 
+                !this.importManager.recipeData.loras || 
+                this.importManager.recipeData.loras.length === 0) {
+                throw new Error('No LoRA information found in this image');
+            }
+            
+            // Find missing LoRAs
+            this.importManager.missingLoras = this.importManager.recipeData.loras.filter(
+                lora => !lora.existsLocally
+            );
+            
+            // Reset import as new flag
+            this.importManager.importAsNew = false;
+            
+            // Proceed to recipe details step
+            this.importManager.showRecipeDetailsStep();
+            
+        } catch (error) {
+            document.getElementById('uploadError').textContent = error.message;
+        } finally {
+            this.importManager.loadingManager.hide();
+        }
+    }
+}

static/js/managers/import/ImportStepManager.js

@@ -0,0 +1,57 @@
+export class ImportStepManager {
+    constructor() {
+        this.injectedStyles = null;
+    }
+
+    removeInjectedStyles() {
+        if (this.injectedStyles && this.injectedStyles.parentNode) {
+            this.injectedStyles.parentNode.removeChild(this.injectedStyles);
+            this.injectedStyles = null;
+        }
+        
+        // Reset inline styles
+        document.querySelectorAll('.import-step').forEach(step => {
+            step.style.cssText = '';
+        });
+    }
+
+    showStep(stepId) {
+        // Remove any injected styles to prevent conflicts
+        this.removeInjectedStyles();
+        
+        // Hide all steps first
+        document.querySelectorAll('.import-step').forEach(step => {
+            step.style.display = 'none';
+        });
+        
+        // Show target step with a monitoring mechanism
+        const targetStep = document.getElementById(stepId);
+        if (targetStep) {
+            // Use direct style setting
+            targetStep.style.display = 'block';
+            
+            // For the locationStep specifically, we need additional measures
+            if (stepId === 'locationStep') {
+                // Create a more persistent style to override any potential conflicts
+                this.injectedStyles = document.createElement('style');
+                this.injectedStyles.innerHTML = `
+                    #locationStep {
+                        display: block !important;
+                        opacity: 1 !important;
+                        visibility: visible !important;
+                    }
+                `;
+                document.head.appendChild(this.injectedStyles);
+                
+                // Force layout recalculation
+                targetStep.offsetHeight;
+            }
+            
+            // Scroll modal content to top
+            const modalContent = document.querySelector('#importModal .modal-content');
+            if (modalContent) {
+                modalContent.scrollTop = 0;
+            }
+        }
+    }
+}

static/js/managers/import/RecipeDataManager.js

@@ -0,0 +1,436 @@
+import { showToast } from '../../utils/uiHelpers.js';
+
+export class RecipeDataManager {
+    constructor(importManager) {
+        this.importManager = importManager;
+    }
+
+    showRecipeDetailsStep() {
+        this.importManager.stepManager.showStep('detailsStep');
+        
+        // Set default recipe name from prompt or image filename
+        const recipeName = document.getElementById('recipeName');
+        
+        // Check if we have recipe metadata from a shared recipe
+        if (this.importManager.recipeData && this.importManager.recipeData.from_recipe_metadata) {
+            // Use title from recipe metadata
+            if (this.importManager.recipeData.title) {
+                recipeName.value = this.importManager.recipeData.title;
+                this.importManager.recipeName = this.importManager.recipeData.title;
+            }
+            
+            // Use tags from recipe metadata
+            if (this.importManager.recipeData.tags && Array.isArray(this.importManager.recipeData.tags)) {
+                this.importManager.recipeTags = [...this.importManager.recipeData.tags];
+                this.updateTagsDisplay();
+            }
+        } else if (this.importManager.recipeData && 
+                  this.importManager.recipeData.gen_params && 
+                  this.importManager.recipeData.gen_params.prompt) {
+            // Use the first 10 words from the prompt as the default recipe name
+            const promptWords = this.importManager.recipeData.gen_params.prompt.split(' ');
+            const truncatedPrompt = promptWords.slice(0, 10).join(' ');
+            recipeName.value = truncatedPrompt;
+            this.importManager.recipeName = truncatedPrompt;
+            
+            // Set up click handler to select all text for easy editing
+            if (!recipeName.hasSelectAllHandler) {
+                recipeName.addEventListener('click', function() {
+                    this.select();
+                });
+                recipeName.hasSelectAllHandler = true;
+            }
+        } else if (this.importManager.recipeImage && !recipeName.value) {
+            // Fallback to image filename if no prompt is available
+            const fileName = this.importManager.recipeImage.name.split('.')[0];
+            recipeName.value = fileName;
+            this.importManager.recipeName = fileName;
+        }
+        
+        // Always set up click handler for easy editing if not already set
+        if (!recipeName.hasSelectAllHandler) {
+            recipeName.addEventListener('click', function() {
+                this.select();
+            });
+            recipeName.hasSelectAllHandler = true;
+        }
+        
+        // Display the uploaded image in the preview
+        const imagePreview = document.getElementById('recipeImagePreview');
+        if (imagePreview) {
+            if (this.importManager.recipeImage) {
+                // For file upload mode
+                const reader = new FileReader();
+                reader.onload = (e) => {
+                    imagePreview.innerHTML = `<img src="${e.target.result}" alt="Recipe preview">`;
+                };
+                reader.readAsDataURL(this.importManager.recipeImage);
+            } else if (this.importManager.recipeData && this.importManager.recipeData.image_base64) {
+                // For URL mode - use the base64 image data returned from the backend
+                imagePreview.innerHTML = `<img src="data:image/jpeg;base64,${this.importManager.recipeData.image_base64}" alt="Recipe preview">`;
+            } else if (this.importManager.importMode === 'url') {
+                // Fallback for URL mode if no base64 data
+                const urlInput = document.getElementById('imageUrlInput');
+                if (urlInput && urlInput.value) {
+                    imagePreview.innerHTML = `<img src="${urlInput.value}" alt="Recipe preview" crossorigin="anonymous">`;
+                }
+            }
+        }
+
+        // Update LoRA count information
+        const totalLoras = this.importManager.recipeData.loras.length;
+        const existingLoras = this.importManager.recipeData.loras.filter(lora => lora.existsLocally).length;
+        const loraCountInfo = document.getElementById('loraCountInfo');
+        if (loraCountInfo) {
+            loraCountInfo.textContent = `(${existingLoras}/${totalLoras} in library)`;
+        }
+        
+        // Display LoRAs list
+        const lorasList = document.getElementById('lorasList');
+        if (lorasList) {
+            lorasList.innerHTML = this.importManager.recipeData.loras.map(lora => {
+                const existsLocally = lora.existsLocally;
+                const isDeleted = lora.isDeleted;
+                const isEarlyAccess = lora.isEarlyAccess;
+                const localPath = lora.localPath || '';
+                
+                // Create status badge based on LoRA status
+                let statusBadge;
+                if (isDeleted) {
+                    statusBadge = `<div class="deleted-badge">
+                        <i class="fas fa-exclamation-circle"></i> Deleted from Civitai
+                    </div>`;
+                } else {
+                    statusBadge = existsLocally ? 
+                        `<div class="local-badge">
+                            <i class="fas fa-check"></i> In Library
+                            <div class="local-path">${localPath}</div>
+                        </div>` :
+                        `<div class="missing-badge">
+                            <i class="fas fa-exclamation-triangle"></i> Not in Library
+                        </div>`;
+                }
+
+                // Early access badge (shown additionally with other badges)
+                let earlyAccessBadge = '';
+                if (isEarlyAccess) {
+                    // Format the early access end date if available
+                    let earlyAccessInfo = 'This LoRA requires early access payment to download.';
+                    if (lora.earlyAccessEndsAt) {
+                        try {
+                            const endDate = new Date(lora.earlyAccessEndsAt);
+                            const formattedDate = endDate.toLocaleDateString();
+                            earlyAccessInfo += ` Early access ends on ${formattedDate}.`;
+                        } catch (e) {
+                            console.warn('Failed to format early access date', e);
+                        }
+                    }
+                    
+                    earlyAccessBadge = `<div class="early-access-badge">
+                        <i class="fas fa-clock"></i> Early Access
+                        <div class="early-access-info">${earlyAccessInfo} Verify that you have purchased early access before downloading.</div>
+                    </div>`;
+                }
+
+                // Format size if available
+                const sizeDisplay = lora.size ? 
+                    `<div class="size-badge">${this.importManager.formatFileSize(lora.size)}</div>` : '';
+
+                return `
+                    <div class="lora-item ${existsLocally ? 'exists-locally' : isDeleted ? 'is-deleted' : 'missing-locally'} ${isEarlyAccess ? 'is-early-access' : ''}">
+                        <div class="lora-thumbnail">
+                            <img src="${lora.thumbnailUrl || '/loras_static/images/no-preview.png'}" alt="LoRA preview">
+                        </div>
+                        <div class="lora-content">
+                            <div class="lora-header">
+                                <h3>${lora.name}</h3>
+                                <div class="badge-container">
+                                    ${statusBadge}
+                                    ${earlyAccessBadge}
+                                </div>
+                            </div>
+                            ${lora.version ? `<div class="lora-version">${lora.version}</div>` : ''}
+                            <div class="lora-info">
+                                ${lora.baseModel ? `<div class="base-model">${lora.baseModel}</div>` : ''}
+                                ${sizeDisplay}
+                                <div class="weight-badge">Weight: ${lora.weight || 1.0}</div>
+                            </div>
+                        </div>
+                    </div>
+                `;
+            }).join('');
+        }
+        
+        // Check for early access loras and show warning if any exist
+        const earlyAccessLoras = this.importManager.recipeData.loras.filter(lora => 
+            lora.isEarlyAccess && !lora.existsLocally && !lora.isDeleted);
+        if (earlyAccessLoras.length > 0) {
+            // Show a warning about early access loras
+            const warningMessage = `
+                <div class="early-access-warning">
+                    <div class="warning-icon"><i class="fas fa-clock"></i></div>
+                    <div class="warning-content">
+                        <div class="warning-title">${earlyAccessLoras.length} LoRA(s) require Early Access</div>
+                        <div class="warning-text">
+                            These LoRAs require a payment to access. Download will fail if you haven't purchased access.
+                            You may need to log in to your Civitai account in browser settings.
+                        </div>
+                    </div>
+                </div>
+            `;
+            
+            // Show the warning message
+            const buttonsContainer = document.querySelector('#detailsStep .modal-actions');
+            if (buttonsContainer) {
+                // Remove existing warning if any
+                const existingWarning = document.getElementById('earlyAccessWarning');
+                if (existingWarning) {
+                    existingWarning.remove();
+                }
+                
+                // Add new warning
+                const warningContainer = document.createElement('div');
+                warningContainer.id = 'earlyAccessWarning';
+                warningContainer.innerHTML = warningMessage;
+                buttonsContainer.parentNode.insertBefore(warningContainer, buttonsContainer);
+            }
+        }
+        
+        // Check for duplicate recipes and display warning if found
+        this.checkAndDisplayDuplicates();
+        
+        // Update Next button state based on missing LoRAs and duplicates
+        this.updateNextButtonState();
+    }
+    
+    checkAndDisplayDuplicates() {
+        // Check if we have duplicate recipes
+        if (this.importManager.recipeData && 
+            this.importManager.recipeData.matching_recipes && 
+            this.importManager.recipeData.matching_recipes.length > 0) {
+            
+            // Store duplicates in the importManager for later use
+            this.importManager.duplicateRecipes = this.importManager.recipeData.matching_recipes;
+            
+            // Create duplicate warning container
+            const duplicateContainer = document.getElementById('duplicateRecipesContainer') || 
+                this.createDuplicateContainer();
+                
+            // Format date helper function
+            const formatDate = (timestamp) => {
+                try {
+                    const date = new Date(timestamp * 1000);
+                    return date.toLocaleDateString() + ' ' + date.toLocaleTimeString();
+                } catch (e) {
+                    return 'Unknown date';
+                }
+            };
+            
+            // Generate the HTML for duplicate recipes warning
+            duplicateContainer.innerHTML = `
+                <div class="duplicate-warning">
+                    <div class="warning-icon"><i class="fas fa-clone"></i></div>
+                    <div class="warning-content">
+                        <div class="warning-title">
+                            ${this.importManager.duplicateRecipes.length} identical ${this.importManager.duplicateRecipes.length === 1 ? 'recipe' : 'recipes'} found in your library
+                        </div>
+                        <div class="warning-text">
+                            These recipes contain the same LoRAs with identical weights.
+                            <button id="toggleDuplicatesList" class="toggle-duplicates-btn">
+                                Show duplicates <i class="fas fa-chevron-down"></i>
+                            </button>
+                        </div>
+                    </div>
+                </div>
+                <div class="duplicate-recipes-list collapsed">
+                    ${this.importManager.duplicateRecipes.map((recipe) => `
+                        <div class="duplicate-recipe-card">
+                            <div class="duplicate-recipe-preview">
+                                <img src="${recipe.file_url}" alt="Recipe preview">
+                                <div class="duplicate-recipe-title">${recipe.title}</div>
+                            </div>
+                            <div class="duplicate-recipe-details">
+                                <div class="duplicate-recipe-date">
+                                    <i class="fas fa-calendar-alt"></i> ${formatDate(recipe.modified)}
+                                </div>
+                                <div class="duplicate-recipe-lora-count">
+                                    <i class="fas fa-layer-group"></i> ${recipe.lora_count} LoRAs
+                                </div>
+                            </div>
+                        </div>
+                    `).join('')}
+                </div>
+            `;
+            
+            // Show the duplicate container
+            duplicateContainer.style.display = 'block';
+            
+            // Add click event for the toggle button
+            const toggleButton = document.getElementById('toggleDuplicatesList');
+            if (toggleButton) {
+                toggleButton.addEventListener('click', () => {
+                    const list = duplicateContainer.querySelector('.duplicate-recipes-list');
+                    if (list) {
+                        list.classList.toggle('collapsed');
+                        const icon = toggleButton.querySelector('i');
+                        if (icon) {
+                            if (list.classList.contains('collapsed')) {
+                                toggleButton.innerHTML = `Show duplicates <i class="fas fa-chevron-down"></i>`;
+                            } else {
+                                toggleButton.innerHTML = `Hide duplicates <i class="fas fa-chevron-up"></i>`;
+                            }
+                        }
+                    }
+                });
+            }
+        } else {
+            // No duplicates, hide the container if it exists
+            const duplicateContainer = document.getElementById('duplicateRecipesContainer');
+            if (duplicateContainer) {
+                duplicateContainer.style.display = 'none';
+            }
+            
+            // Reset duplicate tracking
+            this.importManager.duplicateRecipes = [];
+        }
+    }
+    
+    createDuplicateContainer() {
+        // Find where to insert the duplicate container
+        const lorasListContainer = document.querySelector('.input-group:has(#lorasList)');
+        
+        if (!lorasListContainer) return null;
+        
+        // Create container
+        const duplicateContainer = document.createElement('div');
+        duplicateContainer.id = 'duplicateRecipesContainer';
+        duplicateContainer.className = 'duplicate-recipes-container';
+        
+        // Insert before the LoRA list
+        lorasListContainer.parentNode.insertBefore(duplicateContainer, lorasListContainer);
+        
+        return duplicateContainer;
+    }
+    
+    updateNextButtonState() {
+        const nextButton = document.querySelector('#detailsStep .primary-btn');
+        const actionsContainer = document.querySelector('#detailsStep .modal-actions');
+        if (!nextButton || !actionsContainer) return;
+        
+        // Always clean up previous warnings and buttons first
+        const existingWarning = document.getElementById('deletedLorasWarning');
+        if (existingWarning) {
+            existingWarning.remove();
+        }
+        
+        // Remove any existing "import anyway" button
+        const importAnywayBtn = document.getElementById('importAnywayBtn');
+        if (importAnywayBtn) {
+            importAnywayBtn.remove();
+        }
+        
+        // Count deleted LoRAs
+        const deletedLoras = this.importManager.recipeData.loras.filter(lora => lora.isDeleted).length;
+        
+        // If we have deleted LoRAs, show a warning
+        if (deletedLoras > 0) {
+            // Create a new warning container above the buttons
+            const buttonsContainer = document.querySelector('#detailsStep .modal-actions') || nextButton.parentNode;
+            const warningContainer = document.createElement('div');
+            warningContainer.id = 'deletedLorasWarning';
+            warningContainer.className = 'deleted-loras-warning';
+            
+            // Create warning message
+            warningContainer.innerHTML = `
+                <div class="warning-icon"><i class="fas fa-exclamation-triangle"></i></div>
+                <div class="warning-content">
+                    <div class="warning-title">${deletedLoras} LoRA(s) have been deleted from Civitai</div>
+                    <div class="warning-text">These LoRAs cannot be downloaded. If you continue, they will remain in the recipe but won't be included when used.</div>
+                </div>
+            `;
+            
+            // Insert before the buttons container
+            buttonsContainer.parentNode.insertBefore(warningContainer, buttonsContainer);
+        }
+        
+        // Check for duplicates but don't change button actions
+        const missingNotDeleted = this.importManager.recipeData.loras.filter(
+            lora => !lora.existsLocally && !lora.isDeleted
+        ).length;
+        
+        // Standard button behavior regardless of duplicates
+        nextButton.classList.remove('warning-btn');
+        
+        if (missingNotDeleted > 0) {
+            nextButton.textContent = 'Download Missing LoRAs';
+        } else {
+            nextButton.textContent = 'Save Recipe';
+        }
+    }
+
+    addTag() {
+        const tagInput = document.getElementById('tagInput');
+        const tag = tagInput.value.trim();
+        
+        if (!tag) return;
+        
+        if (!this.importManager.recipeTags.includes(tag)) {
+            this.importManager.recipeTags.push(tag);
+            this.updateTagsDisplay();
+        }
+        
+        tagInput.value = '';
+    }
+    
+    removeTag(tag) {
+        this.importManager.recipeTags = this.importManager.recipeTags.filter(t => t !== tag);
+        this.updateTagsDisplay();
+    }
+    
+    updateTagsDisplay() {
+        const tagsContainer = document.getElementById('tagsContainer');
+        
+        if (this.importManager.recipeTags.length === 0) {
+            tagsContainer.innerHTML = '<div class="empty-tags">No tags added</div>';
+            return;
+        }
+        
+        tagsContainer.innerHTML = this.importManager.recipeTags.map(tag => `
+            <div class="recipe-tag">
+                ${tag}
+                <i class="fas fa-times" onclick="importManager.removeTag('${tag}')"></i>
+            </div>
+        `).join('');
+    }
+
+    proceedFromDetails() {
+        // Validate recipe name
+        if (!this.importManager.recipeName) {
+            showToast('Please enter a recipe name', 'error');
+            return;
+        }
+        
+        // Automatically mark all deleted LoRAs as excluded
+        if (this.importManager.recipeData && this.importManager.recipeData.loras) {
+            this.importManager.recipeData.loras.forEach(lora => {
+                if (lora.isDeleted) {
+                    lora.exclude = true;
+                }
+            });
+        }
+        
+        // Update missing LoRAs list to exclude deleted LoRAs
+        this.importManager.missingLoras = this.importManager.recipeData.loras.filter(lora => 
+            !lora.existsLocally && !lora.isDeleted);
+        
+        // If we have downloadable missing LoRAs, go to location step
+        if (this.importManager.missingLoras.length > 0) {
+            // Store only downloadable LoRAs for the download step
+            this.importManager.downloadableLoRAs = this.importManager.missingLoras;
+            this.importManager.proceedToLocation();
+        } else {
+            // Otherwise, save the recipe directly
+            this.importManager.saveRecipe();
+        }
+    }
+}

static/js/recipes.js

@@ -1,11 +1,13 @@
 // Recipe manager module
 import { appCore } from './core.js';
 import { ImportManager } from './managers/ImportManager.js';
-import { RecipeCard } from './components/RecipeCard.js';
 import { RecipeModal } from './components/RecipeModal.js';
-import { getCurrentPageState } from './state/index.js';
+import { getCurrentPageState, state } from './state/index.js';
 import { getSessionItem, removeSessionItem } from './utils/storageHelpers.js';
 import { RecipeContextMenu } from './components/ContextMenu/index.js';
+import { DuplicatesManager } from './components/DuplicatesManager.js';
+import { initializeInfiniteScroll, refreshVirtualScroll } from './utils/infiniteScroll.js';
+import { resetAndReload, refreshRecipes } from './api/recipeApi.js';
 
 class RecipeManager {
     constructor() {
@@ -18,12 +20,15 @@ class RecipeManager {
         // Initialize RecipeModal
         this.recipeModal = new RecipeModal();
         
+        // Initialize DuplicatesManager
+        this.duplicatesManager = new DuplicatesManager(this);
+        
         // Add state tracking for infinite scroll
         this.pageState.isLoading = false;
         this.pageState.hasMore = true;
         
-        // Custom filter state
-        this.customFilter = {
+        // Custom filter state - move to pageState for compatibility with virtual scrolling
+        this.pageState.customFilter = {
             active: false,
             loraName: null,
             loraHash: null,
@@ -44,13 +49,10 @@ class RecipeManager {
         // Check for custom filter parameters in session storage
         this._checkCustomFilter();
         
-        // Load initial set of recipes
-        await this.loadRecipes();
-        
         // Expose necessary functions to the page
         this._exposeGlobalFunctions();
         
-        // Initialize common page features (lazy loading, infinite scroll)
+        // Initialize common page features
         appCore.initializePageFeatures();
     }
     
@@ -82,7 +84,7 @@ class RecipeManager {
         
         // Set custom filter if any parameter is present
         if (filterLoraName || filterLoraHash || viewRecipeId) {
-            this.customFilter = {
+            this.pageState.customFilter = {
                 active: true,
                 loraName: filterLoraName,
                 loraHash: filterLoraHash,
@@ -103,11 +105,11 @@ class RecipeManager {
         // Update text based on filter type
         let filterText = '';
         
-        if (this.customFilter.recipeId) {
+        if (this.pageState.customFilter.recipeId) {
             filterText = 'Viewing specific recipe';
-        } else if (this.customFilter.loraName) {
+        } else if (this.pageState.customFilter.loraName) {
             // Format with Lora name
-            const loraName = this.customFilter.loraName;
+            const loraName = this.pageState.customFilter.loraName;
             const displayName = loraName.length > 25 ? 
                 loraName.substring(0, 22) + '...' : 
                 loraName;
@@ -120,8 +122,8 @@ class RecipeManager {
         // Update indicator text and show it
         textElement.innerHTML = filterText;
         // Add title attribute to show the lora name as a tooltip
-        if (this.customFilter.loraName) {
-            textElement.setAttribute('title', this.customFilter.loraName);
+        if (this.pageState.customFilter.loraName) {
+            textElement.setAttribute('title', this.pageState.customFilter.loraName);
         }
         indicator.classList.remove('hidden');
         
@@ -144,7 +146,7 @@ class RecipeManager {
     
     _clearCustomFilter() {
         // Reset custom filter
-        this.customFilter = {
+        this.pageState.customFilter = {
             active: false,
             loraName: null,
             loraHash: null,
@@ -162,8 +164,8 @@ class RecipeManager {
         removeSessionItem('lora_to_recipe_filterLoraHash');
         removeSessionItem('viewRecipeId');
         
-        // Reload recipes without custom filter
-        this.loadRecipes();
+        // Reset and refresh the virtual scroller
+        refreshVirtualScroll();
     }
     
     initEventListeners() {
@@ -172,99 +174,21 @@ class RecipeManager {
         if (sortSelect) {
             sortSelect.addEventListener('change', () => {
                 this.pageState.sortBy = sortSelect.value;
-                this.loadRecipes();
+                refreshVirtualScroll();
             });
         }
     }
     
+    // This method is kept for compatibility but now uses virtual scrolling
     async loadRecipes(resetPage = true) {
-        try {
-            // Show loading indicator
-            document.body.classList.add('loading');
-            this.pageState.isLoading = true;
-            
-            // Reset to first page if requested
-            if (resetPage) {
-                this.pageState.currentPage = 1;
-                // Clear grid if resetting
-                const grid = document.getElementById('recipeGrid');
-                if (grid) grid.innerHTML = '';
-            }
-            
-            // If we have a specific recipe ID to load
-            if (this.customFilter.active && this.customFilter.recipeId) {
-                await this._loadSpecificRecipe(this.customFilter.recipeId);
-                return;
-            }
-            
-            // Build query parameters
-            const params = new URLSearchParams({
-                page: this.pageState.currentPage,
-                page_size: this.pageState.pageSize || 20,
-                sort_by: this.pageState.sortBy
-            });
-            
-            // Add custom filter for Lora if present
-            if (this.customFilter.active && this.customFilter.loraHash) {
-                params.append('lora_hash', this.customFilter.loraHash);
-                
-                // Skip other filters when using custom filter
-                params.append('bypass_filters', 'true');
-            } else {
-                // Normal filtering logic
-                
-                // Add search filter if present
-                if (this.pageState.filters.search) {
-                    params.append('search', this.pageState.filters.search);
-                    
-                    // Add search option parameters
-                    if (this.pageState.searchOptions) {
-                        params.append('search_title', this.pageState.searchOptions.title.toString());
-                        params.append('search_tags', this.pageState.searchOptions.tags.toString());
-                        params.append('search_lora_name', this.pageState.searchOptions.loraName.toString());
-                        params.append('search_lora_model', this.pageState.searchOptions.loraModel.toString());
-                        params.append('fuzzy', 'true');
-                    }
-                }
-                
-                // Add base model filters
-                if (this.pageState.filters.baseModel && this.pageState.filters.baseModel.length) {
-                    params.append('base_models', this.pageState.filters.baseModel.join(','));
-                }
-                
-                // Add tag filters
-                if (this.pageState.filters.tags && this.pageState.filters.tags.length) {
-                    params.append('tags', this.pageState.filters.tags.join(','));
-                }
-            }
-
-            // Fetch recipes
-            const response = await fetch(`/api/recipes?${params.toString()}`);
-            
-            if (!response.ok) {
-                throw new Error(`Failed to load recipes: ${response.statusText}`);
-            }
-            
-            const data = await response.json();
-
-            // Update recipes grid
-            this.updateRecipesGrid(data, resetPage);
-            
-            // Update pagination state based on current page and total pages
-            this.pageState.hasMore = data.page < data.total_pages;
-            
-            // Increment the page number AFTER successful loading
-            if (data.items.length > 0) {
-                this.pageState.currentPage++;
-            }
-            
-        } catch (error) {
-            console.error('Error loading recipes:', error);
-            appCore.showToast('Failed to load recipes', 'error');
-        } finally {
-            // Hide loading indicator
-            document.body.classList.remove('loading');
-            this.pageState.isLoading = false;
+        // Skip loading if in duplicates mode
+        const pageState = getCurrentPageState();
+        if (pageState.duplicatesMode) {
+            return;
+        }
+        
+        if (resetPage) {
+            refreshVirtualScroll();
         }
     }
     
@@ -272,100 +196,44 @@ class RecipeManager {
      * Refreshes the recipe list by first rebuilding the cache and then loading recipes
      */
     async refreshRecipes() {
-        try {           
-            // Call the new endpoint to rebuild the recipe cache
-            const response = await fetch('/api/recipes/scan');
-            
-            if (!response.ok) {
-                const data = await response.json();
-                throw new Error(data.error || 'Failed to refresh recipe cache');
-            }
-            
-            // After successful cache rebuild, load the recipes
-            await this.loadRecipes(true);
-            
-            appCore.showToast('Refresh complete', 'success');
-        } catch (error) {
-            console.error('Error refreshing recipes:', error);
-            appCore.showToast(error.message || 'Failed to refresh recipes', 'error');
-            
-            // Still try to load recipes even if scan failed
-            await this.loadRecipes(true);
-        }
-    }
-    
-    async _loadSpecificRecipe(recipeId) {
-        try {
-            // Fetch specific recipe by ID
-            const response = await fetch(`/api/recipe/${recipeId}`);
-            
-            if (!response.ok) {
-                throw new Error(`Failed to load recipe: ${response.statusText}`);
-            }
-            
-            const recipe = await response.json();
-            
-            // Create a data structure that matches the expected format
-            const recipeData = {
-                items: [recipe],
-                total: 1,
-                page: 1,
-                page_size: 1,
-                total_pages: 1
-            };
-            
-            // Update grid with single recipe
-            this.updateRecipesGrid(recipeData, true);
-            
-            // Pagination not needed for single recipe
-            this.pageState.hasMore = false;
-            
-            // Show recipe details modal
-            setTimeout(() => {
-                this.showRecipeDetails(recipe);
-            }, 300);
-            
-        } catch (error) {
-            console.error('Error loading specific recipe:', error);
-            appCore.showToast('Failed to load recipe details', 'error');
-            
-            // Clear the filter and show all recipes
-            this._clearCustomFilter();
-        }
-    }
-    
-    updateRecipesGrid(data, resetGrid = true) {
-        const grid = document.getElementById('recipeGrid');
-        if (!grid) return;
-        
-        // Check if data exists and has items
-        if (!data.items || data.items.length === 0) {
-            if (resetGrid) {
-                grid.innerHTML = `
-                    <div class="placeholder-message">
-                        <p>No recipes found</p>
-                        <p>Add recipe images to your recipes folder to see them here.</p>
-                    </div>
-                `;
-            }
-            return;
-        }
-        
-        // Clear grid if resetting
-        if (resetGrid) {
-            grid.innerHTML = '';
-        }
-        
-        // Create recipe cards
-        data.items.forEach(recipe => {
-            const recipeCard = new RecipeCard(recipe, (recipe) => this.showRecipeDetails(recipe));
-            grid.appendChild(recipeCard.element);
-        });
+        return refreshRecipes();
     }
     
     showRecipeDetails(recipe) {
         this.recipeModal.showRecipeDetails(recipe);
     }
+    
+    // Duplicate detection and management methods
+    async findDuplicateRecipes() {
+        return await this.duplicatesManager.findDuplicates();
+    }
+    
+    selectLatestDuplicates() {
+        this.duplicatesManager.selectLatestDuplicates();
+    }
+    
+    deleteSelectedDuplicates() {
+        this.duplicatesManager.deleteSelectedDuplicates();
+    }
+
+    confirmDeleteDuplicates() {
+        this.duplicatesManager.confirmDeleteDuplicates();
+    }
+    
+    exitDuplicateMode() {
+        // Clear the grid first to prevent showing old content temporarily
+        const recipeGrid = document.getElementById('recipeGrid');
+        if (recipeGrid) {
+            recipeGrid.innerHTML = '';
+        }
+        
+        this.duplicatesManager.exitDuplicateMode();
+        
+        // Use a small delay before initializing to ensure DOM is ready
+        setTimeout(() => {
+            initializeInfiniteScroll('recipes');
+        }, 100);
+    }
 }
 
 // Initialize components

static/js/state/index.js

@@ -27,6 +27,7 @@ export const state = {
             hasMore: true,
             sortBy: 'name',
             activeFolder: null,
+            activeLetterFilter: null, // New property for letter filtering
             previewVersions: loraPreviewVersions,
             searchManager: null,
             searchOptions: {
@@ -64,6 +65,7 @@ export const state = {
             },
             pageSize: 20,
             showFavoritesOnly: false,
+            duplicatesMode: false, // Add flag for duplicates mode
         },
         
         checkpoints: {

static/js/utils/VirtualScroller.js

@@ -0,0 +1,807 @@
+import { state, getCurrentPageState } from '../state/index.js';
+import { showToast } from './uiHelpers.js';
+
+export class VirtualScroller {
+    constructor(options) {
+        // Configuration
+        this.gridElement = options.gridElement;
+        this.createItemFn = options.createItemFn;
+        this.fetchItemsFn = options.fetchItemsFn;
+        this.overscan = options.overscan || 5; // Extra items to render above/below viewport
+        this.containerElement = options.containerElement || this.gridElement.parentElement;
+        this.scrollContainer = options.scrollContainer || this.containerElement;
+        this.batchSize = options.batchSize || 50;
+        this.pageSize = options.pageSize || 100;
+        this.itemAspectRatio = 896/1152; // Aspect ratio of cards
+        this.rowGap = options.rowGap || 20; // Add vertical gap between rows (default 20px)
+        
+        // Add data windowing enable/disable flag
+        this.enableDataWindowing = options.enableDataWindowing !== undefined ? options.enableDataWindowing : false;
+
+        // State
+        this.items = []; // All items metadata
+        this.renderedItems = new Map(); // Map of rendered DOM elements by index
+        this.totalItems = 0;
+        this.isLoading = false;
+        this.hasMore = true;
+        this.lastScrollTop = 0;
+        this.scrollDirection = 'down';
+        this.lastRenderRange = { start: 0, end: 0 };
+        this.pendingScroll = null;
+        this.resizeObserver = null;
+
+        // Data windowing parameters
+        this.windowSize = options.windowSize || 2000; // ±1000 items from current view
+        this.windowPadding = options.windowPadding || 500; // Buffer before loading more
+        this.dataWindow = { start: 0, end: 0 }; // Current data window indices
+        this.absoluteWindowStart = 0; // Start index in absolute terms
+        this.fetchingWindow = false; // Flag to track window fetching state
+
+        // Responsive layout state
+        this.itemWidth = 0;
+        this.itemHeight = 0;
+        this.columnsCount = 0;
+        this.gridPadding = 12; // Gap between cards
+        this.columnGap = 12; // Horizontal gap
+
+        // Add loading timeout state
+        this.loadingTimeout = null;
+        this.loadingTimeoutDuration = options.loadingTimeoutDuration || 15000; // 15 seconds default
+
+        // Initialize
+        this.initializeContainer();
+        this.setupEventListeners();
+        this.calculateLayout();
+    }
+
+    initializeContainer() {
+        // Add virtual scroll class to grid
+        this.gridElement.classList.add('virtual-scroll');
+
+        // Set the container to have relative positioning
+        if (getComputedStyle(this.containerElement).position === 'static') {
+            this.containerElement.style.position = 'relative';
+        }
+
+        // Create a spacer element with the total height
+        this.spacerElement = document.createElement('div');
+        this.spacerElement.className = 'virtual-scroll-spacer';
+        this.spacerElement.style.width = '100%';
+        this.spacerElement.style.height = '0px'; // Will be updated as items are loaded
+        this.spacerElement.style.pointerEvents = 'none';
+        
+        // The grid will be used for the actual visible items
+        this.gridElement.style.position = 'relative';
+        this.gridElement.style.minHeight = '0';
+        
+        // Place the spacer inside the grid container
+        this.gridElement.appendChild(this.spacerElement);
+    }
+
+    calculateLayout() {
+        // Get container width and style information
+        const containerWidth = this.containerElement.clientWidth;
+        const containerStyle = getComputedStyle(this.containerElement);
+        const paddingLeft = parseInt(containerStyle.paddingLeft, 10) || 0;
+        const paddingRight = parseInt(containerStyle.paddingRight, 10) || 0;
+        
+        // Calculate available content width (excluding padding)
+        const availableContentWidth = containerWidth - paddingLeft - paddingRight;
+        
+        // Get compact mode setting
+        const compactMode = state.global.settings?.compactMode || false;
+        
+        // Set exact column counts and grid widths to match CSS container widths
+        let maxColumns, maxGridWidth;
+        
+        // Match exact column counts and CSS container width values
+        if (window.innerWidth >= 3000) { // 4K
+            maxColumns = compactMode ? 10 : 8;
+            maxGridWidth = 2400; // Match exact CSS container width for 4K
+        } else if (window.innerWidth >= 2000) { // 2K/1440p
+            maxColumns = compactMode ? 8 : 6;
+            maxGridWidth = 1800; // Match exact CSS container width for 2K
+        } else {
+            // 1080p
+            maxColumns = compactMode ? 7 : 5;
+            maxGridWidth = 1400; // Match exact CSS container width for 1080p
+        }
+        
+        // Calculate baseCardWidth based on desired column count and available space
+        // Formula: (maxGridWidth - (columns-1)*gap) / columns
+        const baseCardWidth = (maxGridWidth - ((maxColumns - 1) * this.columnGap)) / maxColumns;
+        
+        // Use the smaller of available content width or max grid width
+        const actualGridWidth = Math.min(availableContentWidth, maxGridWidth);
+        
+        // Set exact column count based on screen size and mode
+        this.columnsCount = maxColumns;
+        
+        // When available width is smaller than maxGridWidth, recalculate columns
+        if (availableContentWidth < maxGridWidth) {
+            // Calculate how many columns can fit in the available space
+            this.columnsCount = Math.max(1, Math.floor(
+                (availableContentWidth + this.columnGap) / (baseCardWidth + this.columnGap)
+            ));
+        }
+        
+        // Calculate actual item width
+        this.itemWidth = (actualGridWidth - (this.columnsCount - 1) * this.columnGap) / this.columnsCount;
+        
+        // Calculate height based on aspect ratio
+        this.itemHeight = this.itemWidth / this.itemAspectRatio;
+        
+        // Calculate the left offset to center the grid within the content area
+        this.leftOffset = Math.max(0, (availableContentWidth - actualGridWidth) / 2);
+        
+        // Log layout info
+        console.log('Virtual Scroll Layout:', {
+            containerWidth,
+            availableContentWidth,
+            actualGridWidth,
+            columnsCount: this.columnsCount,
+            itemWidth: this.itemWidth,
+            itemHeight: this.itemHeight,
+            leftOffset: this.leftOffset,
+            paddingLeft,
+            paddingRight,
+            compactMode,
+            maxColumns,
+            baseCardWidth,
+            rowGap: this.rowGap
+        });
+
+        // Update grid element max-width to match available width
+        this.gridElement.style.maxWidth = `${actualGridWidth}px`;
+        
+        // Add or remove compact-mode class for style adjustments
+        if (compactMode) {
+            this.gridElement.classList.add('compact-mode');
+        } else {
+            this.gridElement.classList.remove('compact-mode');
+        }
+        
+        // Update spacer height
+        this.updateSpacerHeight();
+        
+        // Re-render with new layout
+        this.clearRenderedItems();
+        this.scheduleRender();
+        
+        return true;
+    }
+
+    setupEventListeners() {
+        // Debounced scroll handler
+        this.scrollHandler = this.debounce(() => this.handleScroll(), 10);
+        this.scrollContainer.addEventListener('scroll', this.scrollHandler);
+        
+        // Window resize handler for layout recalculation
+        this.resizeHandler = this.debounce(() => {
+            this.calculateLayout();
+        }, 150);
+        
+        window.addEventListener('resize', this.resizeHandler);
+        
+        // Use ResizeObserver for more accurate container size detection
+        if (typeof ResizeObserver !== 'undefined') {
+            this.resizeObserver = new ResizeObserver(this.debounce(() => {
+                this.calculateLayout();
+            }, 150));
+            
+            this.resizeObserver.observe(this.containerElement);
+        }
+    }
+
+    async initialize() {
+        try {
+            await this.loadInitialBatch();
+            this.scheduleRender();
+        } catch (err) {
+            console.error('Failed to initialize virtual scroller:', err);
+            showToast('Failed to load items', 'error');
+        }
+    }
+
+    async loadInitialBatch() {
+        const pageState = getCurrentPageState();
+        if (this.isLoading) return;
+        
+        this.isLoading = true;
+        this.setLoadingTimeout(); // Add loading timeout safety
+        
+        try {
+            const { items, totalItems, hasMore } = await this.fetchItemsFn(1, this.pageSize);
+            
+            // Initialize the data window with the first batch of items
+            this.items = items || [];
+            this.totalItems = totalItems || 0;
+            this.hasMore = hasMore;
+            this.dataWindow = { start: 0, end: this.items.length };
+            this.absoluteWindowStart = 0;
+            
+            // Update the spacer height based on the total number of items
+            this.updateSpacerHeight();
+            
+            // Check if there are no items and show placeholder if needed
+            if (this.items.length === 0) {
+                this.showNoItemsPlaceholder();
+            } else {
+                this.removeNoItemsPlaceholder();
+            }
+            
+            // Reset page state to sync with our virtual scroller
+            pageState.currentPage = 2; // Next page to load would be 2
+            pageState.hasMore = this.hasMore;
+            pageState.isLoading = false;
+            
+            return { items, totalItems, hasMore };
+        } catch (err) {
+            console.error('Failed to load initial batch:', err);
+            this.showNoItemsPlaceholder('Failed to load items. Please try refreshing the page.');
+            throw err;
+        } finally {
+            this.isLoading = false;
+            this.clearLoadingTimeout(); // Clear the timeout
+        }
+    }
+
+    async loadMoreItems() {
+        const pageState = getCurrentPageState();
+        if (this.isLoading || !this.hasMore) return;
+        
+        this.isLoading = true;
+        pageState.isLoading = true;
+        this.setLoadingTimeout(); // Add loading timeout safety
+        
+        try {
+            console.log('Loading more items, page:', pageState.currentPage);
+            const { items, hasMore } = await this.fetchItemsFn(pageState.currentPage, this.pageSize);
+            
+            if (items && items.length > 0) {
+                this.items = [...this.items, ...items];
+                this.hasMore = hasMore;
+                pageState.hasMore = hasMore;
+                
+                // Update page for next request
+                pageState.currentPage++;
+                
+                // Update the spacer height
+                this.updateSpacerHeight();
+                
+                // Render the newly loaded items if they're in view
+                this.scheduleRender();
+                
+                console.log(`Loaded ${items.length} more items, total now: ${this.items.length}`);
+            } else {
+                this.hasMore = false;
+                pageState.hasMore = false;
+                console.log('No more items to load');
+            }
+            
+            return items;
+        } catch (err) {
+            console.error('Failed to load more items:', err);
+            showToast('Failed to load more items', 'error');
+        } finally {
+            this.isLoading = false;
+            pageState.isLoading = false;
+            this.clearLoadingTimeout(); // Clear the timeout
+        }
+    }
+
+    // Add new methods for loading timeout
+    setLoadingTimeout() {
+        // Clear any existing timeout first
+        this.clearLoadingTimeout();
+        
+        // Set a new timeout to prevent loading state from getting stuck
+        this.loadingTimeout = setTimeout(() => {
+            if (this.isLoading) {
+                console.warn('Loading timeout occurred. Resetting loading state.');
+                this.isLoading = false;
+                const pageState = getCurrentPageState();
+                pageState.isLoading = false;
+            }
+        }, this.loadingTimeoutDuration);
+    }
+
+    clearLoadingTimeout() {
+        if (this.loadingTimeout) {
+            clearTimeout(this.loadingTimeout);
+            this.loadingTimeout = null;
+        }
+    }
+
+    updateSpacerHeight() {
+        if (this.columnsCount === 0) return;
+        
+        // Calculate total rows needed based on total items and columns
+        const totalRows = Math.ceil(this.totalItems / this.columnsCount);
+        // Add row gaps to the total height calculation
+        const totalHeight = totalRows * this.itemHeight + (totalRows - 1) * this.rowGap;
+        
+        // Update spacer height to represent all items
+        this.spacerElement.style.height = `${totalHeight}px`;
+    }
+
+    getVisibleRange() {
+        const scrollTop = this.scrollContainer.scrollTop;
+        const viewportHeight = this.scrollContainer.clientHeight;
+        
+        // Calculate the visible row range, accounting for row gaps
+        const rowHeight = this.itemHeight + this.rowGap;
+        const startRow = Math.floor(scrollTop / rowHeight);
+        const endRow = Math.ceil((scrollTop + viewportHeight) / rowHeight);
+        
+        // Add overscan for smoother scrolling
+        const overscanRows = this.overscan;
+        const firstRow = Math.max(0, startRow - overscanRows);
+        const lastRow = Math.min(Math.ceil(this.totalItems / this.columnsCount), endRow + overscanRows);
+        
+        // Calculate item indices
+        const firstIndex = firstRow * this.columnsCount;
+        const lastIndex = Math.min(this.totalItems, lastRow * this.columnsCount);
+        
+        return { start: firstIndex, end: lastIndex };
+    }
+
+    // Update the scheduleRender method to check for disabled state
+    scheduleRender() {
+        if (this.disabled || this.renderScheduled) return;
+        
+        this.renderScheduled = true;
+        requestAnimationFrame(() => {
+            this.renderItems();
+            this.renderScheduled = false;
+        });
+    }
+
+    // Update the renderItems method to check for disabled state
+    renderItems() {
+        if (this.disabled || this.items.length === 0 || this.columnsCount === 0) return;
+        
+        const { start, end } = this.getVisibleRange();
+        
+        // Check if render range has significantly changed
+        const isSameRange = 
+            start >= this.lastRenderRange.start && 
+            end <= this.lastRenderRange.end &&
+            Math.abs(start - this.lastRenderRange.start) < 10;
+            
+        if (isSameRange) return;
+        
+        this.lastRenderRange = { start, end };
+        
+        // Determine which items need to be added and removed
+        const currentIndices = new Set();
+        for (let i = start; i < end && i < this.items.length; i++) {
+            currentIndices.add(i);
+        }
+        
+        // Remove items that are no longer visible
+        for (const [index, element] of this.renderedItems.entries()) {
+            if (!currentIndices.has(index)) {
+                element.remove();
+                this.renderedItems.delete(index);
+            }
+        }
+        
+        // Use DocumentFragment for batch DOM operations
+        const fragment = document.createDocumentFragment();
+        
+        // Add new visible items to the fragment
+        for (let i = start; i < end && i < this.items.length; i++) {
+            if (!this.renderedItems.has(i)) {
+                const item = this.items[i];
+                const element = this.createItemElement(item, i);
+                fragment.appendChild(element);
+                this.renderedItems.set(i, element);
+            }
+        }
+        
+        // Add the fragment to the grid (single DOM operation)
+        if (fragment.childNodes.length > 0) {
+            this.gridElement.appendChild(fragment);
+        }
+        
+        // If we're close to the end and have more items to load, fetch them
+        if (end > this.items.length - (this.columnsCount * 2) && this.hasMore && !this.isLoading) {
+            this.loadMoreItems();
+        }
+        
+        // Check if we need to slide the data window
+        this.slideDataWindow();
+    }
+
+    clearRenderedItems() {
+        this.renderedItems.forEach(element => element.remove());
+        this.renderedItems.clear();
+        this.lastRenderRange = { start: 0, end: 0 };
+    }
+
+    refreshWithData(items, totalItems, hasMore) {
+        this.items = items || [];
+        this.totalItems = totalItems || 0;
+        this.hasMore = hasMore;
+        this.updateSpacerHeight();
+        
+        // Check if there are no items and show placeholder if needed
+        if (this.items.length === 0) {
+            this.showNoItemsPlaceholder();
+        } else {
+            this.removeNoItemsPlaceholder();
+        }
+        
+        // Clear all rendered items and redraw
+        this.clearRenderedItems();
+        this.scheduleRender();
+    }
+
+    createItemElement(item, index) {
+        // Create the DOM element
+        const element = this.createItemFn(item);
+        
+        // Add virtual scroll item class
+        element.classList.add('virtual-scroll-item');
+        
+        // Calculate the position
+        const row = Math.floor(index / this.columnsCount);
+        const col = index % this.columnsCount;
+        
+        // Calculate precise positions with row gap included
+        const topPos = row * (this.itemHeight + this.rowGap);
+        
+        // Position correctly with leftOffset (no need to add padding as absolute
+        // positioning is already relative to the padding edge of the container)
+        const leftPos = this.leftOffset + (col * (this.itemWidth + this.columnGap));
+        
+        // Position the element with absolute positioning
+        element.style.position = 'absolute';
+        element.style.left = `${leftPos}px`;
+        element.style.top = `${topPos}px`;
+        element.style.width = `${this.itemWidth}px`;
+        element.style.height = `${this.itemHeight}px`;
+        
+        return element;
+    }
+
+    handleScroll() {
+        // Determine scroll direction
+        const scrollTop = this.scrollContainer.scrollTop;
+        this.scrollDirection = scrollTop > this.lastScrollTop ? 'down' : 'up';
+        this.lastScrollTop = scrollTop;
+        
+        // Handle large jumps in scroll position - check if we need to fetch a new window
+        const { scrollHeight } = this.scrollContainer;
+        const scrollRatio = scrollTop / scrollHeight;
+        
+        // Only perform data windowing if the feature is enabled
+        if (this.enableDataWindowing && this.totalItems > this.windowSize) {
+            const estimatedIndex = Math.floor(scrollRatio * this.totalItems);
+            const currentWindowStart = this.absoluteWindowStart;
+            const currentWindowEnd = currentWindowStart + this.items.length;
+            
+            // If the estimated position is outside our current window by a significant amount
+            if (estimatedIndex < currentWindowStart || estimatedIndex > currentWindowEnd) {
+                // Fetch a new data window centered on the estimated position
+                this.fetchDataWindow(Math.max(0, estimatedIndex - Math.floor(this.windowSize / 2)));
+                return; // Skip normal rendering until new data is loaded
+            }
+        }
+        
+        // Render visible items
+        this.scheduleRender();
+        
+        // If we're near the bottom and have more items, load them
+        const { clientHeight } = this.scrollContainer;
+        const scrollBottom = scrollTop + clientHeight;
+        
+        // Fix the threshold calculation - use percentage of remaining height instead
+        // We'll trigger loading when within 20% of the bottom of rendered content
+        const remainingScroll = scrollHeight - scrollBottom;
+        const scrollThreshold = Math.min(
+            // Either trigger when within 20% of the total height from bottom
+            scrollHeight * 0.2,
+            // Or when within 2 rows of content from the bottom, whichever is larger
+            (this.itemHeight + this.rowGap) * 2
+        );
+        
+        const shouldLoadMore = remainingScroll <= scrollThreshold;
+        
+        if (shouldLoadMore && this.hasMore && !this.isLoading) {
+            this.loadMoreItems();
+        }
+    }
+
+    // Method to fetch data for a specific window position
+    async fetchDataWindow(targetIndex) {
+        // Skip if data windowing is disabled or already fetching
+        if (!this.enableDataWindowing || this.fetchingWindow) return;
+        
+        this.fetchingWindow = true;
+        
+        try {
+            // Calculate which page we need to fetch based on target index
+            const targetPage = Math.floor(targetIndex / this.pageSize) + 1;
+            console.log(`Fetching data window for index ${targetIndex}, page ${targetPage}`);
+            
+            const { items, totalItems, hasMore } = await this.fetchItemsFn(targetPage, this.pageSize);
+            
+            if (items && items.length > 0) {
+                // Calculate new absolute window start
+                this.absoluteWindowStart = (targetPage - 1) * this.pageSize;
+                
+                // Replace the entire data window with new items
+                this.items = items;
+                this.dataWindow = { 
+                    start: 0,
+                    end: items.length
+                };
+                
+                this.totalItems = totalItems || 0;
+                this.hasMore = hasMore;
+                
+                // Update the current page for future fetches
+                const pageState = getCurrentPageState();
+                pageState.currentPage = targetPage + 1;
+                pageState.hasMore = hasMore;
+                
+                // Update the spacer height and clear current rendered items
+                this.updateSpacerHeight();
+                this.clearRenderedItems();
+                this.scheduleRender();
+                
+                console.log(`Loaded ${items.length} items for window at absolute index ${this.absoluteWindowStart}`);
+            }
+        } catch (err) {
+            console.error('Failed to fetch data window:', err);
+            showToast('Failed to load items at this position', 'error');
+        } finally {
+            this.fetchingWindow = false;
+        }
+    }
+
+    // Method to slide the data window if we're approaching its edges
+    async slideDataWindow() {
+        // Skip if data windowing is disabled
+        if (!this.enableDataWindowing) return;
+        
+        const { start, end } = this.getVisibleRange();
+        const windowStart = this.dataWindow.start;
+        const windowEnd = this.dataWindow.end;
+        const absoluteIndex = this.absoluteWindowStart + windowStart;
+        
+        // Calculate the midpoint of the visible range
+        const visibleMidpoint = Math.floor((start + end) / 2);
+        const absoluteMidpoint = this.absoluteWindowStart + visibleMidpoint;
+        
+        // Check if we're too close to the window edges
+        const closeToStart = start - windowStart < this.windowPadding;
+        const closeToEnd = windowEnd - end < this.windowPadding;
+        
+        // If we're close to either edge and have total items > window size
+        if ((closeToStart || closeToEnd) && this.totalItems > this.windowSize) {
+            // Calculate a new target index centered around the current viewport
+            const halfWindow = Math.floor(this.windowSize / 2);
+            const targetIndex = Math.max(0, absoluteMidpoint - halfWindow);
+            
+            // Don't fetch a new window if we're already showing items near the beginning
+            if (targetIndex === 0 && this.absoluteWindowStart === 0) {
+                return;
+            }
+            
+            // Don't fetch if we're showing the end of the list and are near the end
+            if (this.absoluteWindowStart + this.items.length >= this.totalItems && 
+                this.totalItems - end < halfWindow) {
+                return;
+            }
+            
+            // Fetch the new data window
+            await this.fetchDataWindow(targetIndex);
+        }
+    }
+
+    reset() {
+        // Remove all rendered items
+        this.clearRenderedItems();
+        
+        // Reset state
+        this.items = [];
+        this.totalItems = 0;
+        this.hasMore = true;
+        
+        // Reset spacer height
+        this.spacerElement.style.height = '0px';
+        
+        // Remove any placeholder
+        this.removeNoItemsPlaceholder();
+        
+        // Schedule a re-render
+        this.scheduleRender();
+    }
+
+    dispose() {
+        // Remove event listeners
+        this.scrollContainer.removeEventListener('scroll', this.scrollHandler);
+        window.removeEventListener('resize', this.resizeHandler);
+        
+        // Clean up the resize observer if present
+        if (this.resizeObserver) {
+            this.resizeObserver.disconnect();
+        }
+        
+        // Remove rendered elements
+        this.clearRenderedItems();
+        
+        // Remove spacer
+        this.spacerElement.remove();
+        
+        // Remove virtual scroll class
+        this.gridElement.classList.remove('virtual-scroll');
+        
+        // Clear any pending timeout
+        this.clearLoadingTimeout();
+    }
+
+    // Add methods to handle placeholder display
+    showNoItemsPlaceholder(message) {
+        // Remove any existing placeholder first
+        this.removeNoItemsPlaceholder();
+        
+        // Create placeholder message
+        const placeholder = document.createElement('div');
+        placeholder.className = 'placeholder-message';
+        
+        // Determine appropriate message based on page type
+        let placeholderText = '';
+        
+        if (message) {
+            placeholderText = message;
+        } else {
+            const pageType = state.currentPageType;
+            
+            if (pageType === 'recipes') {
+                placeholderText = `
+                    <p>No recipes found</p>
+                    <p>Add recipe images to your recipes folder to see them here.</p>
+                `;
+            } else if (pageType === 'loras') {
+                placeholderText = `
+                    <p>No LoRAs found</p>
+                    <p>Add LoRAs to your models folder to see them here.</p>
+                `;
+            } else if (pageType === 'checkpoints') {
+                placeholderText = `
+                    <p>No checkpoints found</p>
+                    <p>Add checkpoints to your models folder to see them here.</p>
+                `;
+            } else {
+                placeholderText = `
+                    <p>No items found</p>
+                    <p>Try adjusting your search filters or add more content.</p>
+                `;
+            }
+        }
+        
+        placeholder.innerHTML = placeholderText;
+        placeholder.id = 'virtualScrollPlaceholder';
+        
+        // Append placeholder to the grid
+        this.gridElement.appendChild(placeholder);
+    }
+
+    removeNoItemsPlaceholder() {
+        const placeholder = document.getElementById('virtualScrollPlaceholder');
+        if (placeholder) {
+            placeholder.remove();
+        }
+    }
+
+    // Utility method for debouncing
+    debounce(func, wait) {
+        let timeout;
+        return function(...args) {
+            const context = this;
+            clearTimeout(timeout);
+            timeout = setTimeout(() => func.apply(context, args), wait);
+        };
+    }
+
+    // Add disable method to stop rendering and events
+    disable() {
+        // Detach scroll event listener
+        this.scrollContainer.removeEventListener('scroll', this.scrollHandler);
+        
+        // Clear all rendered items from the DOM
+        this.clearRenderedItems();
+        
+        // Hide the spacer element
+        if (this.spacerElement) {
+            this.spacerElement.style.display = 'none';
+        }
+        
+        // Flag as disabled
+        this.disabled = true;
+        
+        console.log('Virtual scroller disabled');
+    }
+
+    // Add enable method to resume rendering and events
+    enable() {
+        if (!this.disabled) return;
+        
+        // Reattach scroll event listener
+        this.scrollContainer.addEventListener('scroll', this.scrollHandler);
+        
+        // Show the spacer element
+        if (this.spacerElement) {
+            this.spacerElement.style.display = 'block';
+        }
+        
+        // Flag as enabled
+        this.disabled = false;
+        
+        // Re-render items
+        this.scheduleRender();
+        
+        console.log('Virtual scroller enabled');
+    }
+
+    // New method to remove an item by file path
+    removeItemByFilePath(filePath) {
+        if (!filePath || this.disabled || this.items.length === 0) return false;
+
+        // Find the index of the item with the matching file path
+        const index = this.items.findIndex(item => 
+            item.file_path === filePath || 
+            item.filepath === filePath || 
+            item.path === filePath
+        );
+
+        if (index === -1) {
+            console.warn(`Item with file path ${filePath} not found in virtual scroller data`);
+            return false;
+        }
+
+        // Remove the item from the data array
+        this.items.splice(index, 1);
+        
+        // Decrement total count
+        this.totalItems = Math.max(0, this.totalItems - 1);
+        
+        // Remove the item from rendered items if it exists
+        if (this.renderedItems.has(index)) {
+            this.renderedItems.get(index).remove();
+            this.renderedItems.delete(index);
+        }
+        
+        // Shift all rendered items with higher indices down by 1
+        const indicesToUpdate = [];
+        
+        // Collect all indices that need to be updated
+        for (const [idx, element] of this.renderedItems.entries()) {
+            if (idx > index) {
+                indicesToUpdate.push(idx);
+            }
+        }
+        
+        // Update the elements and map entries
+        for (const idx of indicesToUpdate) {
+            const element = this.renderedItems.get(idx);
+            this.renderedItems.delete(idx);
+            // The item is now at the previous index
+            this.renderedItems.set(idx - 1, element);
+        }
+        
+        // Update the spacer height to reflect the new total
+        this.updateSpacerHeight();
+        
+        // Re-render to ensure proper layout
+        this.clearRenderedItems();
+        this.scheduleRender();
+        
+        console.log(`Removed item with file path ${filePath} from virtual scroller data`);
+        return true;
+    }
+}

static/js/utils/cardUpdater.js

@@ -125,4 +125,65 @@ export function updateLoraCard(filePath, updates, newFilePath) {
     });
     
     return loraCard; // Return the updated card element for chaining
+}
+
+/**
+ * Update the recipe card after metadata edits in the modal
+ * @param {string} recipeId - ID of the recipe to update
+ * @param {Object} updates - Object containing the updates (title, tags, source_path)
+ */
+export function updateRecipeCard(recipeId, updates) {
+    // Find the card with matching recipe ID
+    const recipeCard = document.querySelector(`.lora-card[data-id="${recipeId}"]`);
+    if (!recipeCard) return;
+
+    // Get the recipe card component instance
+    const recipeCardInstance = recipeCard._recipeCardInstance;
+    
+    // Update card dataset and visual elements based on the updates object
+    Object.entries(updates).forEach(([key, value]) => {
+        // Update dataset
+        recipeCard.dataset[key] = value;
+
+        // Update visual elements based on the property
+        switch(key) {
+            case 'title':
+                // Update the title in the recipe object
+                if (recipeCardInstance && recipeCardInstance.recipe) {
+                    recipeCardInstance.recipe.title = value;
+                }
+                
+                // Update the title shown in the card
+                const modelNameElement = recipeCard.querySelector('.model-name');
+                if (modelNameElement) modelNameElement.textContent = value;
+                break;
+                
+            case 'tags':
+                // Update tags in the recipe object (not displayed on card UI)
+                if (recipeCardInstance && recipeCardInstance.recipe) {
+                    recipeCardInstance.recipe.tags = value;
+                }
+                
+                // Store in dataset as JSON string
+                try {
+                    if (typeof value === 'string') {
+                        recipeCard.dataset.tags = value;
+                    } else {
+                        recipeCard.dataset.tags = JSON.stringify(value);
+                    }
+                } catch (e) {
+                    console.error('Failed to update recipe tags:', e);
+                }
+                break;
+                
+            case 'source_path':
+                // Update source_path in the recipe object (not displayed on card UI)
+                if (recipeCardInstance && recipeCardInstance.recipe) {
+                    recipeCardInstance.recipe.source_path = value;
+                }
+                break;
+        }
+    });
+    
+    return recipeCard; // Return the updated card element for chaining
 }

static/js/utils/constants.js

@@ -33,9 +33,11 @@ export const BASE_MODELS = {
     NOOBAI: "NoobAI",
     ILLUSTRIOUS: "Illustrious",
     PONY: "Pony",
+    HIDREAM: "HiDream",
     
     // Video models
     SVD: "SVD",
+    LTXV: "LTXV",
     WAN_VIDEO: "Wan Video",
     HUNYUAN_VIDEO: "Hunyuan Video",
     
@@ -69,6 +71,7 @@ export const BASE_MODEL_CLASSES = {
     
     // Video models
     [BASE_MODELS.SVD]: "svd",
+    [BASE_MODELS.LTXV]: "ltxv",
     [BASE_MODELS.WAN_VIDEO]: "wan-video",
     [BASE_MODELS.HUNYUAN_VIDEO]: "hunyuan-video",
     
@@ -84,6 +87,7 @@ export const BASE_MODEL_CLASSES = {
     [BASE_MODELS.NOOBAI]: "noobai",
     [BASE_MODELS.ILLUSTRIOUS]: "il",
     [BASE_MODELS.PONY]: "pony",
+    [BASE_MODELS.HIDREAM]: "hidream",
     
     // Default
     [BASE_MODELS.UNKNOWN]: "unknown"

static/js/utils/formatters.js

@@ -0,0 +1,12 @@
+/**
+ * Format a file size in bytes to a human-readable string
+ * @param {number} bytes - The size in bytes
+ * @returns {string} Formatted size string (e.g., "1.5 MB")
+ */
+export function formatFileSize(bytes) {
+    if (!bytes || isNaN(bytes)) return '';
+    
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return (bytes / Math.pow(1024, i)).toFixed(2) + ' ' + sizes[i];
+}

static/js/utils/infiniteScroll.js

@@ -1,12 +1,53 @@
 import { state, getCurrentPageState } from '../state/index.js';
-import { loadMoreLoras } from '../api/loraApi.js';
-import { loadMoreCheckpoints } from '../api/checkpointApi.js';
-import { debounce } from './debounce.js';
+import { VirtualScroller } from './VirtualScroller.js';
+import { createLoraCard, setupLoraCardEventDelegation } from '../components/LoraCard.js';
+import { createCheckpointCard } from '../components/CheckpointCard.js';
+import { fetchLorasPage } from '../api/loraApi.js';
+import { fetchCheckpointsPage } from '../api/checkpointApi.js';
+import { showToast } from './uiHelpers.js';
 
-export function initializeInfiniteScroll(pageType = 'loras') {
-    // Clean up any existing observer
-    if (state.observer) {
-        state.observer.disconnect();
+// Function to dynamically import the appropriate card creator based on page type
+async function getCardCreator(pageType) {
+    if (pageType === 'loras') {
+        return createLoraCard;
+    } else if (pageType === 'recipes') {
+        // Import the RecipeCard module
+        const { RecipeCard } = await import('../components/RecipeCard.js');
+        
+        // Return a wrapper function that creates a recipe card element
+        return (recipe) => {
+            const recipeCard = new RecipeCard(recipe, (recipe) => {
+                if (window.recipeManager) {
+                    window.recipeManager.showRecipeDetails(recipe);
+                }
+            });
+            return recipeCard.element;
+        };
+    } else if (pageType === 'checkpoints') {
+        return createCheckpointCard;
+    }
+    return null;
+}
+
+// Function to get the appropriate data fetcher based on page type
+async function getDataFetcher(pageType) {
+    if (pageType === 'loras') {
+        return fetchLorasPage;
+    } else if (pageType === 'recipes') {
+        // Import the recipeApi module and use the fetchRecipesPage function
+        const { fetchRecipesPage } = await import('../api/recipeApi.js');
+        return fetchRecipesPage;
+    } else if (pageType === 'checkpoints') {
+        return fetchCheckpointsPage;
+    }
+    return null;
+}
+
+export async function initializeInfiniteScroll(pageType = 'loras') {
+    // Clean up any existing virtual scroller
+    if (state.virtualScroller) {
+        state.virtualScroller.dispose();
+        state.virtualScroller = null;
     }
 
     // Set the current page type
@@ -14,107 +55,100 @@ export function initializeInfiniteScroll(pageType = 'loras') {
     
     // Get the current page state
     const pageState = getCurrentPageState();
+    
+    // Skip initializing if in duplicates mode (for recipes page)
+    if (pageType === 'recipes' && pageState.duplicatesMode) {
+        console.log('Skipping virtual scroll initialization - duplicates mode is active');
+        return;
+    }
 
-    // Determine the load more function and grid ID based on page type
-    let loadMoreFunction;
+    // Use virtual scrolling for all page types
+    await initializeVirtualScroll(pageType);
+    
+    // Setup event delegation for lora cards if on the loras page
+    if (pageType === 'loras') {
+        setupLoraCardEventDelegation();
+    }
+}
+
+async function initializeVirtualScroll(pageType) {
+    // Determine the grid ID based on page type
     let gridId;
     
     switch (pageType) {
         case 'recipes':
-            loadMoreFunction = () => {
-                if (!pageState.isLoading && pageState.hasMore) {
-                    window.recipeManager.loadRecipes(false); // false to not reset pagination
-                }
-            };
             gridId = 'recipeGrid';
             break;
         case 'checkpoints':
-            loadMoreFunction = () => {
-                if (!pageState.isLoading && pageState.hasMore) {
-                    loadMoreCheckpoints(false); // false to not reset
-                }
-            };
             gridId = 'checkpointGrid';
             break;
         case 'loras':
         default:
-            loadMoreFunction = () => {
-                if (!pageState.isLoading && pageState.hasMore) {
-                    loadMoreLoras(false); // false to not reset
-                }
-            };
             gridId = 'loraGrid';
             break;
     }
 
-    const debouncedLoadMore = debounce(loadMoreFunction, 100);
-    
     const grid = document.getElementById(gridId);
+    
     if (!grid) {
-        console.warn(`Grid with ID "${gridId}" not found for infinite scroll`);
+        console.warn(`Grid with ID "${gridId}" not found for virtual scroll`);
         return;
     }
     
-    // Remove any existing sentinel
-    const existingSentinel = document.getElementById('scroll-sentinel');
-    if (existingSentinel) {
-        existingSentinel.remove();
+    // Change this line to get the actual scrolling container
+    const scrollContainer = document.querySelector('.page-content');
+    const gridContainer = scrollContainer.querySelector('.container');
+    
+    if (!gridContainer) {
+        console.warn('Grid container element not found for virtual scroll');
+        return;
     }
     
-    // Create a sentinel element after the grid (not inside it)
-    const sentinel = document.createElement('div');
-    sentinel.id = 'scroll-sentinel';
-    sentinel.style.width = '100%';
-    sentinel.style.height = '20px';
-    sentinel.style.visibility = 'hidden'; // Make it invisible but still affect layout
-    
-    // Insert after grid instead of inside
-    grid.parentNode.insertBefore(sentinel, grid.nextSibling);
-    
-    // Create observer with appropriate settings, slightly different for checkpoints page
-    const observerOptions = {
-        threshold: 0.1,
-        rootMargin: pageType === 'checkpoints' ? '0px 0px 200px 0px' : '0px 0px 100px 0px'
-    };
-    
-    // Initialize the observer
-    state.observer = new IntersectionObserver((entries) => {
-        const target = entries[0];
-        if (target.isIntersecting && !pageState.isLoading && pageState.hasMore) {
-            debouncedLoadMore();
+    try {
+        // Get the card creator and data fetcher for this page type
+        const createCardFn = await getCardCreator(pageType);
+        const fetchDataFn = await getDataFetcher(pageType);
+        
+        if (!createCardFn || !fetchDataFn) {
+            throw new Error(`Required components not available for ${pageType} page`);
         }
-    }, observerOptions);
-    
-    // Start observing
-    state.observer.observe(sentinel);
-    
-    // Clean up any existing scroll event listener
-    if (state.scrollHandler) {
-        window.removeEventListener('scroll', state.scrollHandler);
-        state.scrollHandler = null;
+        
+        // Initialize virtual scroller with renamed container elements
+        state.virtualScroller = new VirtualScroller({
+            gridElement: grid,
+            containerElement: gridContainer,
+            scrollContainer: scrollContainer,
+            createItemFn: createCardFn,
+            fetchItemsFn: fetchDataFn,
+            pageSize: 100,
+            rowGap: 20,
+            enableDataWindowing: false // Explicitly set to false to disable data windowing
+        });
+        
+        // Initialize the virtual scroller
+        await state.virtualScroller.initialize();
+        
+        // Add grid class for CSS styling
+        grid.classList.add('virtual-scroll');
+        
+    } catch (error) {
+        console.error(`Error initializing virtual scroller for ${pageType}:`, error);
+        showToast(`Failed to initialize ${pageType} page. Please reload.`, 'error');
+        
+        // Fallback: show a message in the grid
+        grid.innerHTML = `
+            <div class="placeholder-message">
+                <h3>Failed to initialize ${pageType}</h3>
+                <p>There was an error loading this page. Please try reloading.</p>
+            </div>
+        `;
     }
-    
-    // Add a simple backup scroll handler
-    const handleScroll = debounce(() => {
-        if (pageState.isLoading || !pageState.hasMore) return;
-        
-        const sentinel = document.getElementById('scroll-sentinel');
-        if (!sentinel) return;
-        
-        const rect = sentinel.getBoundingClientRect();
-        const windowHeight = window.innerHeight;
-        
-        if (rect.top < windowHeight + 200) {
-            debouncedLoadMore();
-        }
-    }, 200);
-    
-    state.scrollHandler = handleScroll;
-    window.addEventListener('scroll', state.scrollHandler);
-    
-    // Clear any existing interval
-    if (state.scrollCheckInterval) {
-        clearInterval(state.scrollCheckInterval);
-        state.scrollCheckInterval = null;
+}
+
+// Export a method to refresh the virtual scroller when filters change
+export function refreshVirtualScroll() {
+    if (state.virtualScroller) {
+        state.virtualScroller.reset();
+        state.virtualScroller.initialize();
     }
 }

static/js/utils/modalUtils.js

@@ -1,15 +1,18 @@
 import { modalManager } from '../managers/ModalManager.js';
+import { excludeLora, deleteModel as deleteLora } from '../api/loraApi.js';
+import { excludeCheckpoint, deleteCheckpoint } from '../api/checkpointApi.js';
 
 let pendingDeletePath = null;
 let pendingModelType = null;
+let pendingExcludePath = null;
+let pendingExcludeModelType = null;
 
 export function showDeleteModal(filePath, modelType = 'lora') {
-    // event.stopPropagation();
     pendingDeletePath = filePath;
     pendingModelType = modelType;
     
     const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
-    const modelName = card.dataset.name;
+    const modelName = card ? card.dataset.name : filePath.split('/').pop();
     const modal = modalManager.getModal('deleteModal').element;
     const modelInfo = modal.querySelector('.delete-model-info');
     
@@ -25,34 +28,17 @@ export function showDeleteModal(filePath, modelType = 'lora') {
 export async function confirmDelete() {
     if (!pendingDeletePath) return;
     
-    const card = document.querySelector(`.lora-card[data-filepath="${pendingDeletePath}"]`);
-    
     try {
-        // Use the appropriate endpoint based on model type
-        const endpoint = pendingModelType === 'checkpoint' ? 
-            '/api/checkpoints/delete' : 
-            '/api/delete_model';
-        
-        const response = await fetch(endpoint, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({ 
-                file_path: pendingDeletePath
-            })
-        });
-
-        if (response.ok) {
-            if (card) {
-                card.remove();
-            }
-            closeDeleteModal();
+        // Use appropriate delete function based on model type
+        if (pendingModelType === 'checkpoint') {
+            await deleteCheckpoint(pendingDeletePath);
         } else {
-            const error = await response.text();
-            alert(`Failed to delete model: ${error}`);
+            await deleteLora(pendingDeletePath);
         }
+        
+        closeDeleteModal();
     } catch (error) {
+        console.error('Error deleting model:', error);
         alert(`Error deleting model: ${error}`);
     }
 }
@@ -61,4 +47,46 @@ export function closeDeleteModal() {
     modalManager.closeModal('deleteModal');
     pendingDeletePath = null;
     pendingModelType = null;
+}
+
+// Functions for the exclude modal
+export function showExcludeModal(filePath, modelType = 'lora') {
+    pendingExcludePath = filePath;
+    pendingExcludeModelType = modelType;
+    
+    const card = document.querySelector(`.lora-card[data-filepath="${filePath}"]`);
+    const modelName = card ? card.dataset.name : filePath.split('/').pop();
+    const modal = modalManager.getModal('excludeModal').element;
+    const modelInfo = modal.querySelector('.exclude-model-info');
+    
+    modelInfo.innerHTML = `
+        <strong>Model:</strong> ${modelName}
+        <br>
+        <strong>File:</strong> ${filePath}
+    `;
+    
+    modalManager.showModal('excludeModal');
+}
+
+export function closeExcludeModal() {
+    modalManager.closeModal('excludeModal');
+    pendingExcludePath = null;
+    pendingExcludeModelType = null;
+}
+
+export async function confirmExclude() {
+    if (!pendingExcludePath) return;
+    
+    try {
+        // Use appropriate exclude function based on model type
+        if (pendingExcludeModelType === 'checkpoint') {
+            await excludeCheckpoint(pendingExcludePath);
+        } else {
+            await excludeLora(pendingExcludePath);
+        }
+        
+        closeExcludeModal();
+    } catch (error) {
+        console.error('Error excluding model:', error);
+    }
 }