Add CLI support for microscopy image enhancement and update README

README.md

@@ -14,6 +14,10 @@ license: apache-2.0
 
 An AI-powered microscopy image enhancement tool using the FLUX.2 model. This application provides intelligent image enhancement while preserving cellular structures and fine details.
 
+**Available in two versions:**
+- 🌐 **Web UI** (Gradio): Interactive web interface with drag-and-drop support
+- ⌨️ **CLI** (Command Line): Batch processing tool for automation and scripting
+
 ## ✨ Features
 
 - **Batch Processing**: Process multiple images at once or entire archived folders
@@ -91,10 +95,46 @@ cd flux-image-enhance
 # Install dependencies
 pip install -r requirements.txt
 
-# Run the application
+# Run the web UI
 python app.py
+
+# Or use the CLI version
+python enhance_cli.py -i input.jpg -o output/
 ```
 
+## ⌨️ CLI Usage
+
+For batch processing and automation, use the command-line interface:
+
+```bash
+# Basic usage
+python enhance_cli.py -i input.jpg -o output/
+
+# Process multiple images
+python enhance_cli.py -i img1.jpg img2.png img3.tif -o output/
+
+# Process entire directory (recursive)
+python enhance_cli.py -i images_folder/ -o output/
+
+# Custom parameters
+python enhance_cli.py -i input.jpg -o output/ \
+  --guidance-scale 3.0 \
+  --steps 40 \
+  --prompt "enhance cellular structure"
+
+# Quiet mode (minimal output)
+python enhance_cli.py -i input.jpg -o output/ --quiet
+```
+
+### CLI Arguments
+
+- `-i, --input`: Input path(s) - image files or directories (required)
+- `-o, --output`: Output directory for enhanced images (required)
+- `-p, --prompt`: Enhancement prompt (optional)
+- `-g, --guidance-scale`: Guidance scale 1.0-5.0 (default: 2.0)
+- `-s, --steps`: Inference steps 10-50 (default: 30)
+- `-q, --quiet`: Quiet mode - minimal output
+
 ## 📋 Requirements
 
 - Python 3.8+

app.py

@@ -1,21 +1,23 @@
+import os
+import zipfile
+import tempfile
+import shutil
+import uuid
+from pathlib import Path
+
 import gradio as gr
 import torch
-import spaces
+import numpy as np
+from PIL import Image
 
 from diffusers import Flux2Pipeline
 from diffusers.utils import load_image
-from pathlib import Path
 
-from PIL import Image
-import os
-import zipfile
 import py7zr
-import tempfile
-import shutil
-import numpy as np
 from skimage.metrics import peak_signal_noise_ratio, structural_similarity
 from skimage.util import img_as_float
 
+
 # =========================
 # Config
 # =========================
@@ -36,8 +38,47 @@ IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif"}
 MODEL_ID = "diffusers/FLUX.2-dev-bnb-4bit"
 TORCH_DTYPE = torch.bfloat16
 
+
 # =========================
-# Global cached pipeline (created only inside GPU runtime)
+# HF Spaces env detection + safe "spaces" decorator
+# =========================
+def _is_hf_space_env() -> bool:
+    """
+    Detect whether we're running on Hugging Face Spaces runtime.
+    Common env vars present in Spaces:
+      - SPACE_ID
+      - HF_SPACE_ID
+      - SYSTEM=spaces
+    """
+    return any(os.getenv(k) for k in ("SPACE_ID", "HF_SPACE_ID")) or (
+        os.getenv("SYSTEM", "").lower() == "spaces"
+    )
+
+
+IS_HF_SPACES = _is_hf_space_env()
+
+try:
+    import spaces  # available on HF Spaces
+except Exception:
+    spaces = None
+
+
+def gpu_decorator(duration: int = 180):
+    """
+    If on HF Spaces and spaces.GPU exists -> use it.
+    Else -> no-op decorator (local runs normally, using local GPU if available).
+    """
+    if IS_HF_SPACES and (spaces is not None) and hasattr(spaces, "GPU"):
+        return spaces.GPU(duration=duration)
+
+    def _noop(fn):
+        return fn
+
+    return _noop
+
+
+# =========================
+# Global cached pipeline
 # =========================
 _pipe = None
 
@@ -92,38 +133,43 @@ def find_images(directory: str):
 
 def _get_pipe():
     """
-    Lazy-load the pipeline (ONLY call this inside a @spaces.GPU function).
+    Lazy-load the pipeline.
+    - On HF Spaces ZeroGPU: MUST be called inside a @spaces.GPU runtime (gpu_decorator handles this).
+    - Locally: will use local GPU.
     """
     global _pipe
 
     if _pipe is None:
         if not torch.cuda.is_available():
-            # On ZeroGPU startup this is False; inside @spaces.GPU it should become True
             raise RuntimeError(
-                "No GPU found in current runtime. "
-                "On HF ZeroGPU you must only load the bnb-4bit model inside a @spaces.GPU function."
+                "No CUDA GPU detected. This 4-bit bnb model requires GPU to load/run."
             )
 
         _pipe = Flux2Pipeline.from_pretrained(
             MODEL_ID,
             torch_dtype=TORCH_DTYPE,
-            # removed fix_mistral_regex=True (it was ignored for Flux2Pipeline)
         )
         _pipe.to("cuda")
 
     return _pipe
 
 
-@spaces.GPU(duration=180)
+@gpu_decorator(duration=180)
 def process_images(files, prompt, guidance_scale, num_steps, progress=gr.Progress()):
     """
     Process uploaded files (images or archives) and return:
     - gallery preview (first 10 pairs)
-    - path to output zip
+    - files download (when only images uploaded)
+    - zip download (when archive uploaded)
     - summary text
     """
     if not files:
-        return None, None, "Please upload at least one file."
+        return (
+            None,
+            gr.update(value=None, visible=False),
+            gr.update(value=None, visible=False),
+            "Please upload at least one file.",
+        )
 
     if not prompt or prompt.strip() == "":
         prompt = DEFAULT_PROMPT
@@ -131,9 +177,16 @@ def process_images(files, prompt, guidance_scale, num_steps, progress=gr.Progres
     guidance_scale = float(guidance_scale)
     num_steps = int(num_steps)
 
-    # Temp dirs
+    # Temp for extraction / staging input
     temp_dir = tempfile.mkdtemp(prefix="flux_in_")
-    output_dir = tempfile.mkdtemp(prefix="flux_out_")
+
+    # IMPORTANT:
+    # Result files MUST remain on disk for Gradio download.
+    # So we create a persistent temp dir and DO NOT delete it in finally.
+    run_id = uuid.uuid4().hex[:10]
+    output_dir = tempfile.mkdtemp(prefix=f"flux_results_{run_id}_")
+
+    has_archive = False
 
     try:
         progress(0.0, desc="Preparing files...")
@@ -144,6 +197,7 @@ def process_images(files, prompt, guidance_scale, num_steps, progress=gr.Progres
             file_ext = Path(file_path).suffix.lower()
 
             if file_ext in [".zip", ".7z"]:
+                has_archive = True
                 progress(0.05, desc=f"Extracting: {Path(file_path).name} ...")
                 extract_dir = os.path.join(temp_dir, Path(file_path).stem)
                 os.makedirs(extract_dir, exist_ok=True)
@@ -158,12 +212,17 @@ def process_images(files, prompt, guidance_scale, num_steps, progress=gr.Progres
                 all_images.append((file_path, Path(file_path).name, None))
 
         if not all_images:
-            return None, None, "No valid images found in uploaded files."
+            return (
+                None,
+                gr.update(value=None, visible=False),
+                gr.update(value=None, visible=False),
+                "No valid images found in uploaded files.",
+            )
 
         total_images = len(all_images)
         progress(0.10, desc=f"Found {total_images} images. Loading model...")
 
-        # Load pipeline INSIDE GPU runtime
+        # Load pipeline (inside GPU runtime on Spaces; local GPU otherwise)
         pipe = _get_pipe()
 
         results = []
@@ -177,10 +236,8 @@ def process_images(files, prompt, guidance_scale, num_steps, progress=gr.Progres
                 desc=f"Processing {idx+1}/{total_images}: {Path(img_path).name}",
             )
 
-            # Load input image
             input_image = load_image(img_path)
 
-            # Run inference
             enhanced_image = pipe(
                 image=input_image,
                 prompt=prompt,
@@ -188,14 +245,10 @@ def process_images(files, prompt, guidance_scale, num_steps, progress=gr.Progres
                 num_inference_steps=num_steps,
             ).images[0]
 
-            # Metrics
             psnr, ssim = calculate_psnr_ssim(input_image, enhanced_image)
 
-            # Output path (preserve structure if from archive)
-            if base_dir:
-                output_rel_path = rel_path
-            else:
-                output_rel_path = rel_path
+            # Preserve structure if from archive
+            output_rel_path = rel_path
 
             out_path = os.path.join(output_dir, output_rel_path)
             os.makedirs(os.path.dirname(out_path), exist_ok=True)
@@ -216,35 +269,25 @@ def process_images(files, prompt, guidance_scale, num_steps, progress=gr.Progres
                     "ssim": ssim,
                 }
             )
+
             metrics_lines.append(
                 f"{output_rel_path}: PSNR={psnr:.2f} dB, SSIM={ssim:.4f}"
             )
 
-        progress(0.92, desc="Packaging ZIP...")
-
-        # Create output zip
-        output_zip_path = os.path.join(
-            tempfile.gettempdir(), "enhanced_images_flux.zip"
-        )
-        with zipfile.ZipFile(output_zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
-            for root, _, fs in os.walk(output_dir):
-                for f in fs:
-                    fp = os.path.join(root, f)
-                    arcname = os.path.relpath(fp, output_dir)
-                    zipf.write(fp, arcname)
-
         avg_psnr = float(np.mean([r["psnr"] for r in results])) if results else 0.0
         avg_ssim = float(np.mean([r["ssim"] for r in results])) if results else 0.0
 
         summary = (
             "✅ Processing completed!\n\n"
+            f"Environment: {'Hugging Face Spaces' if IS_HF_SPACES else 'Local'}\n"
+            f"GPU available: {torch.cuda.is_available()}\n\n"
             f"Total images processed: {total_images}\n"
             f"Average PSNR: {avg_psnr:.2f} dB\n"
             f"Average SSIM: {avg_ssim:.4f}\n\n"
             "Individual metrics:\n" + "\n".join(metrics_lines)
         )
 
-        # Build gallery preview (first 10 results -> 20 images: original+enhanced)
+        # Build gallery preview (first 10 results -> original+enhanced)
         gallery_images = []
         for r in results[:10]:
             gallery_images.append((r["original"], f"Original: {r['filename']}"))
@@ -255,18 +298,53 @@ def process_images(files, prompt, guidance_scale, num_steps, progress=gr.Progres
                 )
             )
 
-        progress(1.0, desc="Done!")
-        return gallery_images, output_zip_path, summary
+        # Decide download output:
+        # - If user uploaded any archive -> provide ZIP
+        # - Else -> provide enhanced files directly
+        if has_archive:
+            progress(0.92, desc="Packaging ZIP...")
+
+            output_zip_path = os.path.join(
+                tempfile.gettempdir(), f"enhanced_images_flux_{run_id}.zip"
+            )
+
+            with zipfile.ZipFile(output_zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+                for root, _, fs in os.walk(output_dir):
+                    for f in fs:
+                        fp = os.path.join(root, f)
+                        arcname = os.path.relpath(fp, output_dir)
+                        zipf.write(fp, arcname)
+
+            progress(1.0, desc="Done!")
+            return (
+                gallery_images,
+                gr.update(value=None, visible=False),  # files hidden
+                gr.update(value=output_zip_path, visible=True),  # zip shown
+                summary,
+            )
+        else:
+            enhanced_paths = [r["output_path"] for r in results]
+            progress(1.0, desc="Done!")
+            return (
+                gallery_images,
+                gr.update(value=enhanced_paths, visible=True),  # files shown
+                gr.update(value=None, visible=False),  # zip hidden
+                summary,
+            )
 
     except Exception as e:
-        return None, None, f"Error during processing: {str(e)}"
+        return (
+            None,
+            gr.update(value=None, visible=False),
+            gr.update(value=None, visible=False),
+            f"Error during processing: {str(e)}",
+        )
 
     finally:
-        # Cleanup temp dirs
+        # Cleanup ONLY input/extraction temp dir.
+        # DO NOT delete output_dir because Gradio downloads need the files to remain.
         if os.path.exists(temp_dir):
             shutil.rmtree(temp_dir, ignore_errors=True)
-        if os.path.exists(output_dir):
-            shutil.rmtree(output_dir, ignore_errors=True)
 
 
 # =========================
@@ -274,7 +352,7 @@ def process_images(files, prompt, guidance_scale, num_steps, progress=gr.Progres
 # =========================
 with gr.Blocks(title="Flux Microscopy Image Enhancement") as demo:
     gr.Markdown(
-        """
+        f"""
 # 🔬 Flux Microscopy Image Enhancement
 
 Upload microscopy images (individual files or compressed archives) for AI-powered enhancement.
@@ -283,11 +361,12 @@ Upload microscopy images (individual files or compressed archives) for AI-powere
 - Images: JPG, PNG, BMP, TIFF
 - Archives: ZIP, 7Z (will process all images inside)
 
-**Features:**
-- Batch processing support
-- Custom enhancement prompts
-- Quality metrics (PSNR & SSIM)
-- Download results as ZIP with `_flux` suffix
+**Download behavior:**
+- If you upload **only images** → you can download the enhanced **image files directly** (`*_flux` suffix)
+- If you upload **a ZIP/7Z** → you can download **one ZIP** (images inside use `*_flux` suffix)
+
+**Runtime detection:**
+- Detected environment: **{"Hugging Face Spaces" if IS_HF_SPACES else "Local"}**
 """
     )
 
@@ -328,19 +407,6 @@ Upload microscopy images (individual files or compressed archives) for AI-powere
 
             process_btn = gr.Button("🚀 Enhance Images", variant="primary", size="lg")
 
-            gr.Markdown("### Example")
-            gr.Examples(
-                examples=[
-                    [None, DEFAULT_PROMPT, GUIDANCE_SCALE, NUM_INFERENCE_STEPS],
-                ],
-                inputs=[
-                    file_input,
-                    prompt_input,
-                    guidance_scale_input,
-                    num_steps_input,
-                ],
-            )
-
         with gr.Column(scale=2):
             gallery_output = gr.Gallery(
                 label="Results Preview (Original vs Enhanced)",
@@ -350,7 +416,12 @@ Upload microscopy images (individual files or compressed archives) for AI-powere
                 object_fit="contain",
             )
 
-            download_output = gr.File(label="📥 Download All Enhanced Images (ZIP)")
+            files_output = gr.Files(
+                label="📥 Download Enhanced Images (Files)", visible=False
+            )
+            zip_output = gr.File(
+                label="📥 Download Enhanced Images (ZIP)", visible=False
+            )
 
             summary_output = gr.Textbox(
                 label="Processing Summary & Metrics",
@@ -361,7 +432,7 @@ Upload microscopy images (individual files or compressed archives) for AI-powere
     process_btn.click(
         fn=process_images,
         inputs=[file_input, prompt_input, guidance_scale_input, num_steps_input],
-        outputs=[gallery_output, download_output, summary_output],
+        outputs=[gallery_output, files_output, zip_output, summary_output],
     )
 
     gr.Markdown(
@@ -372,8 +443,8 @@ Upload microscopy images (individual files or compressed archives) for AI-powere
 - **Inference Steps**: 30 (balanced quality and speed)
 
 ### Quality Metrics
-- **PSNR** (Peak Signal-to-Noise Ratio): Higher is better (>30 dB is good)
-- **SSIM** (Structural Similarity Index): Closer to 1.0 is better (>0.9 is excellent)
+- **PSNR** (Peak Signal-to-Noise Ratio): Higher is better
+- **SSIM** (Structural Similarity Index): Closer to 1.0 is better
 """
     )
 

enhance_cli.py

@@ -0,0 +1,369 @@
+#!/usr/bin/env python3
+"""
+Flux Microscopy Image Enhancement - Command Line Interface
+Process microscopy images with AI-powered enhancement using argparse for all parameters
+"""
+
+import argparse
+import torch
+from diffusers import Flux2Pipeline
+from diffusers.utils import load_image
+from pathlib import Path
+from PIL import Image
+import os
+import shutil
+import numpy as np
+from skimage.metrics import peak_signal_noise_ratio, structural_similarity
+from skimage.util import img_as_float
+import sys
+from typing import List, Tuple
+
+# =========================
+# Config
+# =========================
+DEFAULT_PROMPT = (
+    "enhance microscopy image with subtle improvements, gently increase cellular boundary clarity, "
+    "preserve original morphological structure, maintain authentic texture patterns, "
+    "minimal noise reduction while keeping fine details intact"
+)
+
+GUIDANCE_SCALE = 2.0
+NUM_INFERENCE_STEPS = 30
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif"}
+
+MODEL_ID = "diffusers/FLUX.2-dev-bnb-4bit"
+TORCH_DTYPE = torch.bfloat16
+
+# =========================
+# Global cached pipeline
+# =========================
+_pipe = None
+
+
+def calculate_psnr_ssim(original: Image.Image, enhanced: Image.Image):
+    """Calculate PSNR and SSIM between original and enhanced images."""
+    orig_float = img_as_float(np.array(original))
+    enh_float = img_as_float(np.array(enhanced))
+
+    # Ensure same shape (crop to min overlap)
+    if orig_float.shape != enh_float.shape:
+        min_h = min(orig_float.shape[0], enh_float.shape[0])
+        min_w = min(orig_float.shape[1], enh_float.shape[1])
+        orig_float = orig_float[:min_h, :min_w]
+        enh_float = enh_float[:min_h, :min_w]
+
+    psnr = peak_signal_noise_ratio(orig_float, enh_float, data_range=1.0)
+
+    if orig_float.ndim == 3:
+        ssim = structural_similarity(
+            orig_float, enh_float, data_range=1.0, channel_axis=-1
+        )
+    else:
+        ssim = structural_similarity(orig_float, enh_float, data_range=1.0)
+
+    return float(psnr), float(ssim)
+
+
+def find_images(directory: str) -> List[str]:
+    """Recursively find all images in a directory."""
+    image_files = []
+    for root, _, files in os.walk(directory):
+        for f in files:
+            if Path(f).suffix.lower() in IMAGE_EXTENSIONS:
+                image_files.append(os.path.join(root, f))
+    return image_files
+
+
+def _get_pipe():
+    """
+    Lazy-load the pipeline on local GPU.
+    """
+    global _pipe
+
+    if _pipe is None:
+        if not torch.cuda.is_available():
+            raise RuntimeError(
+                "No GPU found. This tool requires a CUDA-compatible GPU to run."
+            )
+
+        print("Loading Flux model...")
+        _pipe = Flux2Pipeline.from_pretrained(
+            MODEL_ID,
+            torch_dtype=TORCH_DTYPE,
+        )
+        _pipe.to("cuda")
+        print(f"Model loaded successfully on GPU: {torch.cuda.get_device_name(0)}")
+
+    return _pipe
+
+
+def process_images_cli(
+    input_paths: List[str],
+    output_dir: str,
+    prompt: str,
+    guidance_scale: float,
+    num_steps: int,
+    verbose: bool = True,
+) -> Tuple[int, List[dict]]:
+    """
+    Process images from input paths and save to output directory.
+
+    Args:
+        input_paths: List of file/directory paths (images or folders)
+        output_dir: Output directory for enhanced images
+        prompt: Enhancement prompt
+        guidance_scale: Guidance scale for inference
+        num_steps: Number of inference steps
+        verbose: Whether to print progress messages
+
+    Returns:
+        Tuple of (total_images_processed, results_list)
+    """
+    if not input_paths:
+        raise ValueError("No input files provided")
+
+    if not prompt or prompt.strip() == "":
+        prompt = DEFAULT_PROMPT
+
+    # Create output directory
+    os.makedirs(output_dir, exist_ok=True)
+
+    try:
+        if verbose:
+            print("=" * 60)
+            print("Flux Microscopy Image Enhancement - CLI")
+            print("=" * 60)
+            print(f"Output directory: {output_dir}")
+            print(f"Prompt: {prompt}")
+            print(f"Guidance scale: {guidance_scale}")
+            print(f"Inference steps: {num_steps}")
+            print("=" * 60)
+
+        all_images = []  # list of tuples: (img_path, rel_path, base_dir_for_rel)
+
+        # Process each input path
+        for input_path in input_paths:
+            if not os.path.exists(input_path):
+                print(f"Warning: Path not found: {input_path}")
+                continue
+
+            # Check if it's a directory
+            if os.path.isdir(input_path):
+                if verbose:
+                    print(f"\n[Scanning] Directory: {input_path} ...")
+
+                images = find_images(input_path)
+                for img_path in images:
+                    rel_path = os.path.relpath(img_path, input_path)
+                    all_images.append((img_path, rel_path, input_path))
+
+                if verbose:
+                    print(f"  Found {len(images)} images in directory")
+
+            # Check if it's an image file
+            elif os.path.isfile(input_path):
+                file_ext = Path(input_path).suffix.lower()
+                if file_ext in IMAGE_EXTENSIONS:
+                    all_images.append((input_path, Path(input_path).name, None))
+                else:
+                    print(f"Warning: Unsupported file format: {input_path}")
+            else:
+                print(f"Warning: Invalid path: {input_path}")
+
+        if not all_images:
+            raise ValueError("No valid images found in input files")
+
+        total_images = len(all_images)
+        if verbose:
+            print(f"\n[Processing] Total images to enhance: {total_images}")
+            print("-" * 60)
+
+        # Load pipeline
+        pipe = _get_pipe()
+
+        results = []
+        metrics_lines = []
+
+        for idx, (img_path, rel_path, base_dir) in enumerate(all_images, 1):
+            if verbose:
+                print(f"\n[{idx}/{total_images}] Processing: {Path(img_path).name}")
+
+            # Load input image
+            input_image = load_image(img_path)
+
+            # Run inference
+            enhanced_image = pipe(
+                image=input_image,
+                prompt=prompt,
+                guidance_scale=guidance_scale,
+                num_inference_steps=num_steps,
+            ).images[0]
+
+            # Calculate metrics
+            psnr, ssim = calculate_psnr_ssim(input_image, enhanced_image)
+
+            if verbose:
+                print(f"  PSNR: {psnr:.2f} dB | SSIM: {ssim:.4f}")
+
+            # Determine output path (preserve structure if from directory)
+            if base_dir:
+                output_rel_path = rel_path
+            else:
+                output_rel_path = rel_path
+
+            out_path = os.path.join(output_dir, output_rel_path)
+            os.makedirs(os.path.dirname(out_path), exist_ok=True)
+
+            # Add _flux suffix
+            out_name = Path(out_path).stem + "_flux" + Path(out_path).suffix
+            out_path = os.path.join(os.path.dirname(out_path), out_name)
+
+            # Save enhanced image
+            enhanced_image.save(out_path)
+
+            if verbose:
+                print(f"  Saved to: {out_path}")
+
+            results.append(
+                {
+                    "original_path": img_path,
+                    "output_path": out_path,
+                    "filename": output_rel_path,
+                    "psnr": psnr,
+                    "ssim": ssim,
+                }
+            )
+
+            metrics_lines.append(
+                f"{output_rel_path}: PSNR={psnr:.2f} dB, SSIM={ssim:.4f}"
+            )
+
+        # Print summary
+        if verbose:
+            avg_psnr = float(np.mean([r["psnr"] for r in results])) if results else 0.0
+            avg_ssim = float(np.mean([r["ssim"] for r in results])) if results else 0.0
+
+            print("\n" + "=" * 60)
+            print("SUMMARY")
+            print("=" * 60)
+            print(f"Total images processed: {total_images}")
+            print(f"Average PSNR: {avg_psnr:.2f} dB")
+            print(f"Average SSIM: {avg_ssim:.4f}")
+            print("\nIndividual metrics:")
+            for line in metrics_lines:
+                print(f"  {line}")
+            print("=" * 60)
+
+        return total_images, results
+
+    except Exception as e:
+        print(f"\nError during processing: {str(e)}", file=sys.stderr)
+        raise
+
+
+def main():
+    """Main entry point for CLI."""
+    parser = argparse.ArgumentParser(
+        description="Flux Microscopy Image Enhancement - Command Line Interface",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Enhance a single image
+  python enhance_cli.py -i input.jpg -o output/
+
+  # Enhance multiple images with custom parameters
+  python enhance_cli.py -i image1.jpg image2.png -o output/ --guidance-scale 3.0 --steps 40
+
+  # Process all images in a directory
+  python enhance_cli.py -i images_folder/ -o output/
+
+  # Process with custom prompt
+  python enhance_cli.py -i input.jpg -o output/ --prompt "enhance cellular structure"
+
+  # Quiet mode (less verbose output)
+  python enhance_cli.py -i input.jpg -o output/ --quiet
+
+Supported formats:
+  - Images: JPG, JPEG, PNG, BMP, TIFF, TIF
+  - Directories: Will recursively process all images inside
+        """,
+    )
+
+    # Required arguments
+    parser.add_argument(
+        "-i",
+        "--input",
+        nargs="+",
+        required=True,
+        help="Input path(s) - image files or directories. Multiple paths supported.",
+    )
+
+    parser.add_argument(
+        "-o", "--output", required=True, help="Output directory for enhanced images"
+    )
+
+    # Optional arguments
+    parser.add_argument(
+        "-p",
+        "--prompt",
+        default=DEFAULT_PROMPT,
+        help=f"Enhancement prompt (default: '{DEFAULT_PROMPT[:50]}...')",
+    )
+
+    parser.add_argument(
+        "-g",
+        "--guidance-scale",
+        type=float,
+        default=GUIDANCE_SCALE,
+        help=f"Guidance scale (1.0-5.0, lower=conservative, higher=creative, default: {GUIDANCE_SCALE})",
+    )
+
+    parser.add_argument(
+        "-s",
+        "--steps",
+        type=int,
+        default=NUM_INFERENCE_STEPS,
+        help=f"Number of inference steps (10-50, more=better quality but slower, default: {NUM_INFERENCE_STEPS})",
+    )
+
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="Quiet mode - reduce output verbosity",
+    )
+
+    args = parser.parse_args()
+
+    # Validate arguments
+    if args.guidance_scale < 1.0 or args.guidance_scale > 5.0:
+        parser.error("guidance-scale must be between 1.0 and 5.0")
+
+    if args.steps < 10 or args.steps > 50:
+        parser.error("steps must be between 10 and 50")
+
+    # Process images
+    try:
+        total, results = process_images_cli(
+            input_paths=args.input,
+            output_dir=args.output,
+            prompt=args.prompt,
+            guidance_scale=args.guidance_scale,
+            num_steps=args.steps,
+            verbose=not args.quiet,
+        )
+
+        if not args.quiet:
+            print("\n✅ Enhancement completed successfully!")
+            print(f"📁 Output directory: {args.output}")
+
+        sys.exit(0)
+
+    except Exception as e:
+        print(f"\n❌ Error: {str(e)}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()