imagex 0.1.0__py3-none-any.whl

imagex/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

imagex/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

imagex/cli.py

@@ -0,0 +1,223 @@
+import argparse
+import sys
+from pathlib import Path
+from typing import Optional
+
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+
+from imagex import __version__
+from imagex.features import get_features
+from imagex.utils.file_ops import find_images
+from imagex.utils.progress import process_files
+
+console = Console()
+
+USAGE = """
+Image processing CLI tool — right in your terminal.
+
+Run without arguments to launch the interactive menu:
+
+    imagex
+
+Features:
+  • Remove Metadata    Strip EXIF/XMP/IPTC (incl. AI generation markers)
+  • Convert Format     JPG ↔ PNG ↔ WEBP ↔ TIFF ↔ BMP ↔ GIF ↔ HEIC
+  • Compress/Optimize  Reduce file size with quality slider
+  • Resize             Percentage, exact dimensions, fit within bounds
+  • Rename Batch       Pattern-based renaming (%%n, %%o)
+  • Add Noise          Gaussian or salt & pepper (bypass AI detection)
+  • Watermark          Add text/image or remove existing
+"""
+
+
+def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="imagex",
+        description="Image processing CLI tool — right in your terminal",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="Run without arguments to launch the interactive menu.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"imagex v{__version__}",
+    )
+    return parser.parse_args(argv)
+
+
+def fmt_size(size: int) -> str:
+    for unit in ("B", "KB", "MB"):
+        if size < 1024:
+            return f"{size:.0f} {unit}"
+        size /= 1024
+    return f"{size:.1f} GB"
+
+
+def show_banner():
+    art = """[bold cyan]
+██╗███╗   ███╗ █████╗  ██████╗ ███████╗██╗  ██╗
+██║████╗ ████║██╔══██╗██╔════╝ ██╔════╝╚██╗██╔╝
+██║██╔████╔██║███████║██║  ███╗█████╗   ╚███╔╝
+██║██║╚██╔╝██║██╔══██║██║   ██║██╔══╝   ██╔██╗
+██║██║ ╚═╝ ██║██║  ██║╚██████╔╝███████╗██╔╝ ██╗
+╚═╝╚═╝     ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝
+[/bold cyan]"""
+
+    text = (
+        f"{art}"
+        f"[white]v{__version__}[/white]\n"
+        "[dim]Image processing, right in ur CLI[/dim]"
+    )
+    console.print(Panel(text, width=60))
+
+
+def select_features() -> Optional[list[str]]:
+    features = get_features()
+
+    if not features:
+        console.print("[red]No features found! Add a .py file to imagex/features/.[/red]")
+        return None
+
+    choices = []
+    for name, info in features.items():
+        label = f"{info['name']:<30} {info['description']}"
+        choices.append(questionary.Choice(title=label, value=name))
+
+    choices.append(questionary.Choice(title="[Done] Quit", value="__quit__"))
+
+    selected = questionary.checkbox(
+        "What do you want to do? (↑↓ to move, Space to toggle, Enter to confirm)",
+        choices=choices,
+    ).ask()
+
+    if not selected:
+        return None
+
+    if "__quit__" in selected:
+        return None
+
+    return selected
+
+
+def ask_output_mode() -> tuple[str, Optional[Path]]:
+    mode = questionary.select(
+        "Where should the processed images go?",
+        choices=[
+            questionary.Choice(
+                title="Overwrite originals (backup created in .imagex_backup/)",
+                value="overwrite",
+            ),
+            questionary.Choice(
+                title="Save to ./output/ folder",
+                value="output",
+            ),
+            questionary.Choice(
+                title="Save to custom folder",
+                value="custom",
+            ),
+        ],
+    ).ask()
+
+    output_dir = None
+    if mode == "custom":
+        custom = questionary.text(
+            "Enter output folder path:",
+            validate=lambda p: len(p.strip()) > 0 or "Path cannot be empty",
+        ).ask()
+        output_dir = Path(custom.strip())
+
+    return mode, output_dir
+
+
+def select_files(all_files: list[Path]) -> Optional[list[Path]]:
+    if not all_files:
+        return None
+
+    if len(all_files) == 1:
+        return all_files
+
+    all_choice = questionary.Choice(
+        title=f"All images ({len(all_files)} files)",
+        value="__all__",
+    )
+
+    file_choices = []
+    for f in all_files:
+        size_str = fmt_size(f.stat().st_size)
+        label = f"{f.name:<50} {size_str:>8}"
+        file_choices.append(questionary.Choice(title=label, value=str(f)))
+
+    selected = questionary.checkbox(
+        "Which images to process? (Space to toggle, Enter to confirm)",
+        choices=[all_choice] + file_choices,
+    ).ask()
+
+    if not selected:
+        return None
+
+    if "__all__" in selected:
+        return all_files
+
+    return [Path(f) for f in selected]
+
+
+def main():
+    _parse_args()
+
+    try:
+        show_banner()
+
+        selected = select_features()
+        if selected is None:
+            console.print("[yellow]No feature selected. Exiting.[/yellow]")
+            return
+
+        all_files = find_images(Path.cwd())
+        if not all_files:
+            console.print("[red]No image files found in current directory.[/red]")
+            console.print("[dim]Supported: .jpg .jpeg .png .webp .tiff .tif .bmp .gif .ico[/dim]")
+            return
+
+        files = select_files(all_files)
+        if not files:
+            console.print("[yellow]No files selected. Exiting.[/yellow]")
+            return
+
+        console.print(f"[green]Selected {len(files)} image(s)[/green]")
+
+        features = get_features()
+        any_needs_output = any(
+            info.get("needs_output", True)
+            for name, info in features.items()
+            if name in selected
+        )
+
+        if any_needs_output:
+            mode, output_dir = ask_output_mode()
+        else:
+            mode, output_dir = "overwrite", None
+
+        for feature_name in selected:
+            info = features[feature_name]
+            ask_args = info.get("ask_args")
+            feature_args = ask_args(files) if ask_args else {}
+            console.print(f"\n[bold]→ {info['name']}[/bold]")
+            process_files(
+                files=files,
+                process_func=info["run"],
+                feature_name=info["name"],
+                output_mode=mode,
+                output_dir=output_dir,
+                args=feature_args,
+            )
+
+        console.print("\n[bold green]✓ All done![/bold green]")
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interrupted. Exiting.[/yellow]")
+        sys.exit(0)
+    except Exception as e:
+        console.print(f"\n[red]Error: {e}[/red]")
+        sys.exit(1)

imagex/config.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+IMAGE_EXTENSIONS = {
+    ".jpg", ".jpeg", ".png", ".webp",
+    ".tiff", ".tif", ".bmp", ".gif", ".ico",
+}
+
+BACKUP_DIR_NAME = ".imagex_backup"
+DEFAULT_OUTPUT_DIR_NAME = "output"
+
+
+def is_image(file: Path) -> bool:
+    return file.suffix.lower() in IMAGE_EXTENSIONS

imagex/features/__init__.py

@@ -0,0 +1,34 @@
+import importlib
+import pkgutil
+from pathlib import Path
+
+REGISTRY: dict[str, dict] = {}
+
+
+def _register(module):
+    name = getattr(module, "NAME", None)
+    description = getattr(module, "DESCRIPTION", "")
+    run_func = getattr(module, "run", None)
+    ask_args_func = getattr(module, "ask_args", None)
+    needs_output = getattr(module, "NEEDS_OUTPUT_MODE", True)
+
+    if name and run_func:
+        REGISTRY[name] = {
+            "name": name,
+            "description": description,
+            "run": run_func,
+            "ask_args": ask_args_func,
+            "needs_output": needs_output,
+            "module": module.__name__,
+        }
+
+
+_features_dir = Path(__file__).parent
+for _finder, _name, _ispkg in pkgutil.iter_modules([str(_features_dir)]):
+    if _name != "__init__":
+        _module = importlib.import_module(f".{_name}", __package__)
+        _register(_module)
+
+
+def get_features() -> dict[str, dict]:
+    return dict(REGISTRY)

imagex/features/add_noise.py

@@ -0,0 +1,80 @@
+import random
+from pathlib import Path
+from typing import Any, Optional
+
+import questionary
+from PIL import Image
+
+NAME = "Add Noise"
+DESCRIPTION = "Add subtle pixel noise (helps bypass AI detection)"
+
+
+def ask_args(files: list[Path]) -> dict[str, Any]:
+    intensity_val = questionary.text(
+        "Noise intensity (1-100, higher = more visible):",
+        default="5",
+        validate=lambda v: v.isdigit() and 1 <= int(v) <= 100 or "Enter 1-100",
+    ).ask()
+
+    noise_type = questionary.select(
+        "Noise type:",
+        choices=[
+            "Gaussian (subtle, uniform)",
+            "Salt & Pepper (random pixels)",
+        ],
+    ).ask()
+
+    return {
+        "intensity": int(intensity_val),
+        "noise_type": "gaussian" if "Gaussian" in noise_type else "salt_pepper",
+    }
+
+
+def run(file: Path, output_path: Path, args: Optional[dict[str, Any]] = None) -> bool:
+    if args is None:
+        msg = "args required for add_noise"
+        raise ValueError(msg)
+
+    intensity = args["intensity"]
+    noise_type = args.get("noise_type", "gaussian")
+    img = Image.open(file)
+
+    if noise_type == "gaussian":
+        _add_gaussian_noise(img, intensity)
+    else:
+        _add_salt_pepper(img, intensity)
+
+    img.save(str(output_path), format=img.format or "JPEG")
+    return True
+
+
+def _add_gaussian_noise(img: Image.Image, intensity: int):
+    pixels = img.load()
+    w, h = img.size
+    scale = intensity / 100
+    noise_range = int(scale * 60)
+    num_pixels = int(w * h * scale * 0.8)
+
+    for _ in range(num_pixels):
+        x = random.randint(0, w - 1)
+        y = random.randint(0, h - 1)
+        px = list(pixels[x, y])
+        for c in range(min(len(px), 3)):
+            px[c] = max(0, min(255, px[c] + random.randint(-noise_range, noise_range)))
+        pixels[x, y] = tuple(px)
+
+
+def _add_salt_pepper(img: Image.Image, intensity: int):
+    pixels = img.load()
+    w, h = img.size
+    scale = intensity / 100
+    num_pixels = int(w * h * scale * 0.3)
+
+    for _ in range(num_pixels):
+        x = random.randint(0, w - 1)
+        y = random.randint(0, h - 1)
+        px = list(pixels[x, y])
+        val = 255 if random.random() < 0.5 else 0
+        for c in range(min(len(px), 3)):
+            px[c] = val
+        pixels[x, y] = tuple(px)

imagex/features/compress.py

@@ -0,0 +1,95 @@
+from pathlib import Path
+from typing import Any, Optional
+
+import questionary
+from PIL import Image
+from rich.console import Console
+
+NAME = "Compress / Optimize"
+DESCRIPTION = "Reduce file size (quality slider, optimization)"
+
+console = Console()
+
+
+def ask_args(files: list[Path]) -> dict[str, Any]:
+    quality = questionary.text(
+        "Quality (1-100):",
+        default="80",
+        validate=lambda v: v.isdigit() and 1 <= int(v) <= 100 or "Enter a number 1-100",
+    ).ask()
+
+    return {"quality": max(1, min(100, int(quality)))}
+
+
+def run(file: Path, output_path: Path, args: Optional[dict[str, Any]] = None) -> bool:
+    if args is None:
+        msg = "args required for compress (quality)"
+        raise ValueError(msg)
+
+    quality = args.get("quality", 80)
+    img = Image.open(file)
+    fmt = img.format
+    original_size = file.stat().st_size
+
+    if fmt == "JPEG":
+        _compress_jpeg(img, output_path, quality)
+    elif fmt == "PNG":
+        _compress_png(img, output_path, quality)
+    elif fmt == "WEBP":
+        _compress_webp(img, output_path, quality)
+    else:
+        _compress_other(img, output_path, fmt, quality)
+
+    new_size = output_path.stat().st_size
+    saved = original_size - new_size
+    pct = (1 - new_size / original_size) * 100 if original_size else 0
+    console.print(
+        f"  [dim]{file.name}: {_fmt_size(original_size)} → {_fmt_size(new_size)} "
+        f"({'−' if saved >= 0 else '+'}{abs(pct):.0f}%)[/dim]"
+    )
+
+    return True
+
+
+def _compress_jpeg(img: Image.Image, output_path: Path, quality: int):
+    if img.mode == "RGBA":
+        bg = Image.new("RGB", img.size, (255, 255, 255))
+        bg.paste(img, mask=img.split()[3])
+        img = bg
+    elif img.mode != "RGB":
+        img = img.convert("RGB")
+    img.save(str(output_path), format="JPEG", quality=quality, optimize=True)
+
+
+def _compress_png(img: Image.Image, output_path: Path, quality: int):
+    if quality < 50:
+        if img.mode == "RGBA":
+            bg = Image.new("RGB", img.size, (255, 255, 255))
+            bg.paste(img, mask=img.split()[3])
+            img = bg
+        elif img.mode != "RGB":
+            img = img.convert("RGB")
+        colors = max(quality * 2, 16)
+        img = img.quantize(colors=colors, method=Image.Quantize.MEDIANCUT)
+        img.save(str(output_path), format="PNG", optimize=True)
+    else:
+        img.save(str(output_path), format="PNG", optimize=True)
+
+
+def _compress_webp(img: Image.Image, output_path: Path, quality: int):
+    img.save(str(output_path), format="WEBP", quality=quality)
+
+
+def _compress_other(img: Image.Image, output_path: Path, fmt: str, quality: int):
+    params = {"format": fmt}
+    if fmt == "GIF":
+        params["save_all"] = True
+    img.save(str(output_path), **params)
+
+
+def _fmt_size(size: int) -> str:
+    for unit in ("B", "KB", "MB"):
+        if size < 1024:
+            return f"{size:.0f} {unit}"
+        size /= 1024
+    return f"{size:.1f} GB"

imagex/features/convert.py

@@ -0,0 +1,96 @@
+from pathlib import Path
+from typing import Any, Optional
+
+import questionary
+from PIL import Image
+
+NAME = "Convert Format"
+DESCRIPTION = "Convert images between formats"
+
+OUTPUT_FORMATS = {
+    "JPEG": ".jpg",
+    "PNG": ".png",
+    "WEBP": ".webp",
+    "TIFF": ".tiff",
+    "BMP": ".bmp",
+    "GIF": ".gif",
+}
+
+HEIF_AVAILABLE = False
+try:
+    import pillow_heif  # noqa: F401
+
+    pillow_heif.register_heif_opener()
+    HEIF_AVAILABLE = True
+    OUTPUT_FORMATS["HEIC"] = ".heic"
+except ImportError:
+    pass
+
+
+def ask_args(files: list[Path]) -> dict[str, Any]:
+    choices = list(OUTPUT_FORMATS.keys())
+    target = questionary.select(
+        "Convert to which format?",
+        choices=choices,
+    ).ask()
+
+    return {
+        "target_format": target,
+        "target_ext": OUTPUT_FORMATS[target],
+    }
+
+
+def run(file: Path, output_path: Path, args: Optional[dict[str, Any]] = None) -> bool:
+    if args is None:
+        msg = "args required for convert (target_format)"
+        raise ValueError(msg)
+
+    target_fmt = args["target_format"]
+
+    img = Image.open(file)
+    actual_output = output_path.with_suffix(args["target_ext"])
+
+    if target_fmt == "JPEG":
+        _save_as_jpeg(img, actual_output)
+    elif target_fmt == "PNG":
+        _save_as_png(img, actual_output)
+    elif target_fmt == "WEBP":
+        _save_as_webp(img, actual_output)
+    elif target_fmt == "TIFF":
+        img.save(str(actual_output), format="TIFF")
+    elif target_fmt == "BMP":
+        img.save(str(actual_output), format="BMP")
+    elif target_fmt == "GIF":
+        img.save(str(actual_output), format="GIF")
+    elif target_fmt == "HEIC":
+        _save_as_heic(img, actual_output)
+
+    return True
+
+
+def _save_as_jpeg(img: Image.Image, output_path: Path):
+    if img.mode == "RGBA":
+        bg = Image.new("RGB", img.size, (255, 255, 255))
+        bg.paste(img, mask=img.split()[3])
+        img = bg
+    elif img.mode != "RGB":
+        img = img.convert("RGB")
+    img.save(str(output_path), format="JPEG")
+
+
+def _save_as_png(img: Image.Image, output_path: Path):
+    img.save(str(output_path), format="PNG")
+
+
+def _save_as_webp(img: Image.Image, output_path: Path):
+    img.save(str(output_path), format="WEBP")
+
+
+def _save_as_heic(img: Image.Image, output_path: Path):
+    if not HEIF_AVAILABLE:
+        msg = (
+            "HEIC support requires pillow-heif.\n"
+            "Install with: pip install pillow-heif"
+        )
+        raise ImportError(msg)
+    img.save(str(output_path), format="HEIF")

imagex/features/remove_metadata.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+from typing import Any, Optional
+
+from PIL import Image
+
+NAME = "Remove Metadata"
+DESCRIPTION = "Strip EXIF/XMP/IPTC data from images"
+
+
+def run(file: Path, output_path: Path, args: Optional[dict[str, Any]] = None) -> bool:
+    img = Image.open(file)
+    fmt = img.format
+
+    if fmt == "JPEG":
+        _clean_jpeg(img, output_path)
+    elif fmt == "PNG":
+        _clean_png(img, output_path)
+    elif fmt == "WEBP":
+        _clean_webp(img, output_path)
+    elif fmt == "TIFF" or fmt == "TIF":
+        _clean_tiff(img, output_path)
+    else:
+        _save_clean(img, output_path, fmt)
+
+    return True
+
+
+def _clean_jpeg(img: Image.Image, output_path: Path):
+    img.save(str(output_path), format="JPEG", exif=b"")
+
+
+def _clean_png(img: Image.Image, output_path: Path):
+    img.save(str(output_path), format="PNG")
+
+
+def _clean_webp(img: Image.Image, output_path: Path):
+    img.save(str(output_path), format="WEBP")
+
+
+def _clean_tiff(img: Image.Image, output_path: Path):
+    img.save(str(output_path), format="TIFF")
+
+
+def _save_clean(img: Image.Image, output_path: Path, fmt: str):
+    params = {}
+    if fmt == "GIF":
+        params["save_all"] = True
+    img.save(str(output_path), format=fmt, **params)

imagex/features/rename_batch.py

@@ -0,0 +1,64 @@
+import shutil
+from pathlib import Path
+from typing import Any, Optional
+
+import questionary
+from rich.console import Console
+
+NAME = "Rename Batch"
+DESCRIPTION = "Rename multiple files with a pattern"
+NEEDS_OUTPUT_MODE = False
+
+console = Console()
+
+
+def ask_args(files: list[Path]) -> dict[str, Any]:
+    sorted_files = sorted(files)
+
+    pattern = questionary.text(
+        "Pattern (use %n for number, %o for original name):",
+        default="img_%n",
+    ).ask()
+
+    start_str = questionary.text("Starting number:", default="1").ask()
+
+    digits_str = questionary.text("Digit padding (e.g. 3 = 001):", default="3").ask()
+
+    start = int(start_str)
+    digits = int(digits_str)
+
+    rename_map = {}
+    for i, f in enumerate(sorted_files):
+        new_stem = pattern.replace("%n", str(start + i).zfill(digits))
+        new_stem = new_stem.replace("%o", f.stem)
+        new_name = new_stem + f.suffix
+        rename_map[str(f)] = new_name
+
+    console.print("\n[bold]Preview:[/bold]")
+    for f in sorted_files:
+        console.print(f"  {f.name}  →  [green]{rename_map[str(f)]}[/green]")
+
+    confirm = questionary.confirm("Proceed with rename?").ask()
+    if not confirm:
+        msg = "Cancelled by user"
+        raise RuntimeError(msg)
+
+    return {
+        "rename_map": rename_map,
+        "sorted_files": [str(f) for f in sorted_files],
+    }
+
+
+def run(file: Path, output_path: Path, args: Optional[dict[str, Any]] = None) -> bool:
+    if args is None:
+        msg = "args required for rename (rename_map)"
+        raise ValueError(msg)
+
+    new_name = args["rename_map"][str(file)]
+    new_path = file.parent / new_name
+
+    if file.name != new_name:
+        shutil.move(str(file), str(new_path))
+        console.print(f"  [dim]{file.name} → {new_name}[/dim]")
+
+    return True

imagex/features/resize.py

@@ -0,0 +1,90 @@
+from pathlib import Path
+from typing import Any, Optional
+
+import questionary
+from PIL import Image
+
+NAME = "Resize"
+DESCRIPTION = "Scale images (dimensions, percentage, or fit within bounds)"
+
+METHODS = {
+    "Percentage": "percentage",
+    "Exact dimensions": "exact",
+    "Fit within (maintain ratio)": "fit",
+}
+
+
+def ask_args(files: list[Path]) -> dict[str, Any]:
+    method_label = questionary.select(
+        "Resize method:",
+        choices=list(METHODS.keys()),
+    ).ask()
+
+    method = METHODS[method_label]
+
+    if method == "percentage":
+        pct = questionary.text(
+            "Percentage of original (e.g. 50 for half size):",
+            default="50",
+            validate=lambda v: v.isdigit() and int(v) > 0 or "Enter a positive number",
+        ).ask()
+        return {"method": "percentage", "value": int(pct)}
+
+    if method == "exact":
+        w = questionary.text(
+            "Width (px):",
+            validate=lambda v: v.isdigit() and int(v) > 0 or "Enter a positive number",
+        ).ask()
+        h = questionary.text(
+            "Height (px):",
+            validate=lambda v: v.isdigit() and int(v) > 0 or "Enter a positive number",
+        ).ask()
+        return {"method": "exact", "width": int(w), "height": int(h)}
+
+    if method == "fit":
+        mw = questionary.text(
+            "Max width (px):",
+            validate=lambda v: v.isdigit() and int(v) > 0 or "Enter a positive number",
+        ).ask()
+        mh = questionary.text(
+            "Max height (px):",
+            validate=lambda v: v.isdigit() and int(v) > 0 or "Enter a positive number",
+        ).ask()
+        return {"method": "fit", "max_width": int(mw), "max_height": int(mh)}
+
+    msg = f"Unknown method: {method}"
+    raise ValueError(msg)
+
+
+def run(file: Path, output_path: Path, args: Optional[dict[str, Any]] = None) -> bool:
+    if args is None:
+        msg = "args required for resize"
+        raise ValueError(msg)
+
+    img = Image.open(file)
+    method = args["method"]
+
+    if method == "percentage":
+        pct = args["value"] / 100
+        new_w = max(1, int(img.width * pct))
+        new_h = max(1, int(img.height * pct))
+    elif method == "exact":
+        new_w = args["width"]
+        new_h = args["height"]
+    elif method == "fit":
+        new_w, new_h = _fit_within(img.width, img.height, args["max_width"], args["max_height"])
+    else:
+        msg = f"Unknown method: {method}"
+        raise ValueError(msg)
+
+    resized = img.resize((new_w, new_h), Image.LANCZOS)
+    resized.save(str(output_path), format=img.format or "JPEG")
+
+    return True
+
+
+def _fit_within(orig_w: int, orig_h: int, max_w: int, max_h: int) -> tuple[int, int]:
+    ratio = min(max_w / orig_w, max_h / orig_h)
+    if ratio >= 1:
+        return orig_w, orig_h
+    return max(1, int(orig_w * ratio)), max(1, int(orig_h * ratio))

imagex/features/watermark.py

@@ -0,0 +1,248 @@
+from pathlib import Path
+from typing import Any, Optional
+
+import questionary
+from PIL import Image, ImageDraw, ImageFilter, ImageFont
+
+from imagex.config import is_image
+
+NAME = "Watermark"
+DESCRIPTION = "Add or remove watermarks from images"
+
+FONT_PATHS = [
+    "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+    "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
+    "/System/Library/Fonts/Helvetica.ttc",
+    "C:\\Windows\\Fonts\\Arial.ttf",
+]
+
+POSITIONS = [
+    "Top-Left",
+    "Top-Right",
+    "Bottom-Left",
+    "Bottom-Right",
+    "Center",
+]
+
+REMOVE_SIZES = ["Small (10%)", "Medium (20%)", "Large (30%)"]
+
+
+def ask_args(files: list[Path]) -> dict[str, Any]:
+    action = questionary.select(
+        "Watermark action:",
+        choices=["Add watermark", "Remove watermark"],
+    ).ask()
+
+    if action == "Add watermark":
+        return _ask_add(files)
+
+    return _ask_remove(files)
+
+
+def _ask_add(files: list[Path]) -> dict[str, Any]:
+    wm_type = questionary.select(
+        "Watermark type:",
+        choices=["Text", "Image (logo)"],
+    ).ask()
+
+    position = questionary.select(
+        "Position:",
+        choices=POSITIONS,
+    ).ask()
+
+    opacity_str = questionary.text(
+        "Opacity (1-100):",
+        default="50",
+        validate=lambda v: v.isdigit() and 1 <= int(v) <= 100 or "Enter 1-100",
+    ).ask()
+
+    args = {
+        "action": "add",
+        "type": "text" if wm_type == "Text" else "image",
+        "position": position,
+        "opacity": max(0, min(255, int(int(opacity_str) * 2.55))),
+    }
+
+    if args["type"] == "text":
+        text = questionary.text("Text content:", default="©").ask()
+        size_str = questionary.text(
+            "Font size (px):",
+            default="36",
+            validate=lambda v: v.isdigit() and int(v) > 0 or "Enter a number",
+        ).ask()
+        color = questionary.text("Color (name or hex):", default="white").ask()
+
+        args["text"] = text
+        args["font_size"] = int(size_str)
+        args["color"] = color
+    else:
+        logo_input = questionary.text("Logo file path:").ask()
+        logo_path = Path(logo_input.strip())
+
+        if not logo_path.exists():
+            msg = f"Logo file not found: {logo_path}"
+            raise FileNotFoundError(msg)
+        if not is_image(logo_path):
+            msg = f"Not an image file: {logo_path}"
+            raise ValueError(msg)
+
+        scale_str = questionary.text(
+            "Logo scale (% of image width):",
+            default="10",
+            validate=lambda v: v.isdigit() and int(v) > 0 or "Enter a number",
+        ).ask()
+
+        args["logo_path"] = str(logo_path)
+        args["scale"] = int(scale_str)
+
+    return args
+
+
+def _ask_remove(files: list[Path]) -> dict[str, Any]:
+    position = questionary.select(
+        "Watermark position:",
+        choices=POSITIONS,
+    ).ask()
+
+    size_choice = questionary.select(
+        "Watermark size:",
+        choices=REMOVE_SIZES,
+    ).ask()
+
+    size_map = {"Small (10%)": 0.1, "Medium (20%)": 0.2, "Large (30%)": 0.3}
+
+    return {
+        "action": "remove",
+        "position": position,
+        "size_ratio": size_map[size_choice],
+    }
+
+
+def run(file: Path, output_path: Path, args: Optional[dict[str, Any]] = None) -> bool:
+    if args is None:
+        msg = "args required for watermark"
+        raise ValueError(msg)
+
+    img = Image.open(file).convert("RGBA")
+    action = args["action"]
+
+    if action == "add":
+        _run_add(img, args)
+    elif action == "remove":
+        _run_remove(img, args)
+    else:
+        msg = f"Unknown action: {action}"
+        raise ValueError(msg)
+
+    out = img.convert("RGB") if img.mode == "RGBA" else img
+    out.save(str(output_path))
+    return True
+
+
+def _run_add(img: Image.Image, args: dict[str, Any]):
+    wm_type = args["type"]
+    position = args["position"]
+    opacity = args["opacity"]
+    w, h = img.size
+    margin = max(20, int(min(w, h) * 0.03))
+
+    if wm_type == "text":
+        overlay = _make_text_overlay(w, h, args)
+    else:
+        overlay = _make_image_overlay(w, h, args)
+
+    if opacity < 255:
+        overlay.putalpha(overlay.split()[3].point(lambda a: int(a * opacity / 255)))
+
+    paste_x, paste_y = _calc_position(w, h, overlay.width, overlay.height, position, margin)
+    img.paste(overlay, (paste_x, paste_y), overlay)
+
+
+def _run_remove(img: Image.Image, args: dict[str, Any]):
+    position = args["position"]
+    ratio = args["size_ratio"]
+    w, h = img.size
+
+    rw = max(10, int(w * ratio))
+    rh = max(10, int(h * ratio))
+    margin = max(5, int(min(w, h) * 0.01))
+
+    rx, ry = _calc_position(w, h, rw, rh, position, margin)
+
+    _fill_region(img, rx, ry, rw, rh)
+
+
+def _calc_position(
+    img_w: int, obj_w: int, img_h: int, obj_h: int, position: str, margin: int
+) -> tuple[int, int]:
+    positions = {
+        "Top-Left": (margin, margin),
+        "Top-Right": (img_w - obj_w - margin, margin),
+        "Bottom-Left": (margin, img_h - obj_h - margin),
+        "Bottom-Right": (img_w - obj_w - margin, img_h - obj_h - margin),
+        "Center": ((img_w - obj_w) // 2, (img_h - obj_h) // 2),
+    }
+    return positions.get(position, (margin, margin))
+
+
+def _make_text_overlay(img_w: int, img_h: int, args: dict[str, Any]) -> Image.Image:
+    text = args["text"]
+    font_size = args["font_size"]
+    color = args["color"]
+
+    font = None
+    for fp in FONT_PATHS:
+        try:
+            font = ImageFont.truetype(fp, font_size)
+            break
+        except (OSError, IOError):
+            continue
+
+    overlay = Image.new("RGBA", (img_w, img_h), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(overlay)
+
+    bbox = draw.textbbox((0, 0), text, font=font)
+    tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]
+
+    text_overlay = Image.new("RGBA", (tw + 20, th + 20), (0, 0, 0, 0))
+    tdraw = ImageDraw.Draw(text_overlay)
+    tdraw.text((10 - bbox[0], 10 - bbox[1]), text, fill=color, font=font)
+
+    return text_overlay
+
+
+def _make_image_overlay(img_w: int, img_h: int, args: dict[str, Any]) -> Image.Image:
+    logo = Image.open(args["logo_path"]).convert("RGBA")
+    scale = args["scale"] / 100
+    new_w = max(10, int(img_w * scale))
+    new_h = int(logo.height * (new_w / logo.width))
+    return logo.resize((new_w, new_h), Image.LANCZOS)
+
+
+def _fill_region(img: Image.Image, rx: int, ry: int, rw: int, rh: int):
+    samples = []
+    border = max(2, int(min(rw, rh) * 0.05))
+    left = max(0, rx - border)
+    right = min(img.width, rx + rw + border)
+    top = max(0, ry - border)
+    bottom = min(img.height, ry + rh + border)
+
+    for x in range(left, right):
+        for y in (top, bottom - 1):
+            if 0 <= y < img.height:
+                samples.append(img.getpixel((x, y)))
+    for y in range(top, bottom):
+        for x in (left, right - 1):
+            if 0 <= x < img.width:
+                samples.append(img.getpixel((x, y)))
+
+    avg_color = tuple(
+        int(sum(c[i] for c in samples) / len(samples)) for i in range(4)
+    ) if samples else (128, 128, 128, 255)
+
+    fill = Image.new("RGBA", (rw, rh), avg_color)
+    img.paste(fill, (rx, ry))
+
+    region = img.crop((rx, ry, rx + rw, ry + rh))
+    blurred = region.filter(ImageFilter.GaussianBlur(radius=max(2, min(rw, rh) // 10)))
+    img.paste(blurred, (rx, ry))

imagex/utils/file_ops.py

@@ -0,0 +1,42 @@
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from imagex.config import BACKUP_DIR_NAME, is_image
+
+
+def find_images(directory: Path) -> list[Path]:
+    files = []
+    for f in sorted(directory.iterdir()):
+        if f.is_file() and is_image(f):
+            files.append(f)
+    return files
+
+
+def backup_file(file: Path) -> Optional[Path]:
+    backup_root = file.parent / BACKUP_DIR_NAME
+    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    backup_dir = backup_root / timestamp
+    backup_dir.mkdir(parents=True, exist_ok=True)
+    dest = backup_dir / file.name
+    shutil.copy2(file, dest)
+    return dest
+
+
+def get_output_path(
+    file: Path,
+    mode: str,
+    output_dir: Optional[Path] = None,
+) -> Path:
+    if mode == "overwrite":
+        return file
+    elif mode == "output":
+        return (file.parent / "output" / file.name).resolve()
+    elif mode == "custom":
+        if output_dir is None:
+            msg = "output_dir required for custom mode"
+            raise ValueError(msg)
+        return output_dir / file.name
+    msg = f"Unknown output mode: {mode}"
+    raise ValueError(msg)

imagex/utils/progress.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from rich.progress import (
+    BarColumn,
+    Progress,
+    TextColumn,
+    TimeRemainingColumn,
+)
+
+from imagex.utils.file_ops import backup_file, get_output_path
+
+
+def process_files(
+    files: list[Path],
+    process_func: Callable[[Path, Path, dict[str, Any]], bool],
+    feature_name: str,
+    output_mode: str,
+    output_dir: Optional[Path] = None,
+    args: Optional[dict[str, Any]] = None,
+):
+    if args is None:
+        args = {}
+
+    with Progress(
+        TextColumn(f"[bold blue]{feature_name}[/bold blue]"),
+        BarColumn(),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        TextColumn("• {task.completed}/{task.total}"),
+        TimeRemainingColumn(),
+    ) as progress:
+        task = progress.add_task("Processing...", total=len(files))
+
+        for file in files:
+            try:
+                output_path = get_output_path(file, output_mode, output_dir)
+
+                if output_mode == "overwrite":
+                    backup_file(file)
+
+                output_path.parent.mkdir(parents=True, exist_ok=True)
+                process_func(file, output_path, args)
+
+            except Exception as e:
+                progress.console.print(
+                    f"[red]✗ {file.name}: {e}[/red]"
+                )
+
+            progress.advance(task)

imagex-0.1.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: imagex
+Version: 0.1.0
+Summary: Image processing CLI tool - right in your terminal
+Author: kushal1o1
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0
+Requires-Dist: questionary>=2.0
+Requires-Dist: Pillow>=10.0
+Provides-Extra: heif
+Requires-Dist: pillow-heif>=0.16; extra == "heif"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: pillow-heif>=0.16; extra == "dev"
+Dynamic: license-file
+
+```
+██╗███╗   ███╗ █████╗  ██████╗ ███████╗██╗  ██╗
+██║████╗ ████║██╔══██╗██╔════╝ ██╔════╝╚██╗██╔╝
+██║██╔████╔██║███████║██║  ███╗█████╗   ╚███╔╝
+██║██║╚██╔╝██║██╔══██║██║   ██║██╔══╝   ██╔██╗
+██║██║ ╚═╝ ██║██║  ██║╚██████╔╝███████╗██╔╝ ██╗
+╚═╝╚═╝     ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝
+```
+
+Image processing CLI tool — right in your terminal.
+
+```bash
+pip install .
+imagex
+```
+
+Navigate to any folder with images and run `imagex`.
+
+## Features
+
+| Feature | Description |
+|---|---|
+| Remove Metadata | Strip EXIF/XMP/IPTC (incl. AI generation markers) |
+| Convert Format | JPG ↔ PNG ↔ WEBP ↔ TIFF ↔ BMP ↔ GIF ↔ HEIC |
+| Compress / Optimize | Reduce file size with quality slider |
+| Resize | Percentage, exact dimensions, fit within bounds |
+| Rename Batch | Pattern-based renaming (%n, %o) |
+| Add Noise | Gaussian or salt & pepper (bypass AI detection) |
+| Watermark | Add text/image or remove existing |
+
+Full details in [OPERATIONS.md](OPERATIONS.md).
+
+## Install
+
+```bash
+# From the repo directory
+pip install .
+
+# Dev mode (changes take effect immediately)
+pip install -e .
+```
+
+Then run `imagex` from any folder.
+
+## Adding Features
+
+See [CONTRIBUTION.md](CONTRIBUTION.md) for the contribution guide.
+
+## License
+
+MIT

imagex-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+imagex/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+imagex/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+imagex/cli.py,sha256=GrXl_QhAx4Kx2XsTLX8WHoB66TwSDlpKqryPe2ksQPw,6978
+imagex/config.py,sha256=DN67otXTTH2wS5X7QYTFdFoeaWRNk9JaXqt6q2RJcto,290
+imagex/features/__init__.py,sha256=M0NHVdKZiijADjzKZiwrDwtaVWvHyMTbKyqM-PmA6rw,951
+imagex/features/add_noise.py,sha256=M1c1mv61v5qvUPi6p0vcAjfFnGq5ExSsABpjIE-VbpI,2268
+imagex/features/compress.py,sha256=fDMVhfVbF2qJsTzY5NOy-8uw41_egXa03Fn_ep9gIEg,2945
+imagex/features/convert.py,sha256=s7hYe7uQ8J5fn9qnhqN1osWeV4w8_vuh4-5VYUBtAM0,2498
+imagex/features/remove_metadata.py,sha256=Y-34esRUaYDVR6CYZ0KiOVs077DVS5OJZEEFbEcdRfs,1234
+imagex/features/rename_batch.py,sha256=AfpXyRSMC476oKQk0da78rk4QR55JeJBowrlkmulDRA,1795
+imagex/features/resize.py,sha256=WMEYv1NCfBvND9g5YCdWDksIpKX6gCitlz7Qe0B7T8M,2835
+imagex/features/watermark.py,sha256=zwBGRdzVvGTvevDBrexsjD5L0ziGVeYPdyqY1l2lxsc,7258
+imagex/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imagex/utils/file_ops.py,sha256=JAYcppgU1p_dBoi_as3mzpPchnOEpejo7riSBsU4reQ,1164
+imagex/utils/progress.py,sha256=HqNDba-CuOVeSZch0dRIb9u-CUXX7v3PBmtc4P-MUoQ,1375
+imagex-0.1.0.dist-info/licenses/LICENSE,sha256=MBapErI6Fowrcdbtzn8ttQz2ywvxLpcd70FDmlnE5e4,1069
+imagex-0.1.0.dist-info/METADATA,sha256=Qbb7VOjk_0E1g1_AzwWwweWT4wAfwUr_dgia5UKz-PE,2615
+imagex-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+imagex-0.1.0.dist-info/entry_points.txt,sha256=Wu0Vacajmuk6OX1Feo2mSsaaICiLjabZifc3EAFJ2aM,43
+imagex-0.1.0.dist-info/top_level.txt,sha256=brNRF_KDuY8Xrn4f0dyG8mgLPoMPrve8GrzLeelF15M,7
+imagex-0.1.0.dist-info/RECORD,,

imagex-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

imagex-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+imagex = imagex.cli:main

imagex-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kushal Baral
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

imagex-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+imagex