@agent-webui/ai-desk-harness-gimp 1.0.29-beta1

package/python/agent-harness/build/lib/cli_anything/gimp/core/filters.py

@@ -0,0 +1,382 @@
+"""GIMP CLI - Filter registry and application module."""
+
+from typing import Dict, Any, List, Optional, Tuple
+
+
+# Filter registry: maps CLI name -> implementation details
+FILTER_REGISTRY = {
+    # Image Adjustments
+    "brightness": {
+        "category": "adjustment",
+        "description": "Adjust image brightness",
+        "params": {"factor": {"type": "float", "default": 1.0, "min": 0.0, "max": 10.0,
+                              "description": "1.0=neutral, >1=brighter, <1=darker"}},
+        "engine": "pillow_enhance",
+        "pillow_class": "Brightness",
+    },
+    "contrast": {
+        "category": "adjustment",
+        "description": "Adjust image contrast",
+        "params": {"factor": {"type": "float", "default": 1.0, "min": 0.0, "max": 10.0,
+                              "description": "1.0=neutral, >1=more contrast"}},
+        "engine": "pillow_enhance",
+        "pillow_class": "Contrast",
+    },
+    "saturation": {
+        "category": "adjustment",
+        "description": "Adjust color saturation",
+        "params": {"factor": {"type": "float", "default": 1.0, "min": 0.0, "max": 10.0,
+                              "description": "1.0=neutral, 0=grayscale, >1=vivid"}},
+        "engine": "pillow_enhance",
+        "pillow_class": "Color",
+    },
+    "sharpness": {
+        "category": "adjustment",
+        "description": "Adjust image sharpness",
+        "params": {"factor": {"type": "float", "default": 1.0, "min": 0.0, "max": 10.0,
+                              "description": "1.0=neutral, >1=sharper, 0=blurred"}},
+        "engine": "pillow_enhance",
+        "pillow_class": "Sharpness",
+    },
+    "autocontrast": {
+        "category": "adjustment",
+        "description": "Automatic contrast stretch",
+        "params": {"cutoff": {"type": "float", "default": 0.0, "min": 0.0, "max": 49.0,
+                              "description": "Percent of lightest/darkest pixels to clip"}},
+        "engine": "pillow_ops",
+        "pillow_func": "autocontrast",
+    },
+    "equalize": {
+        "category": "adjustment",
+        "description": "Equalize histogram",
+        "params": {},
+        "engine": "pillow_ops",
+        "pillow_func": "equalize",
+    },
+    "invert": {
+        "category": "adjustment",
+        "description": "Invert colors (negative)",
+        "params": {},
+        "engine": "pillow_ops",
+        "pillow_func": "invert",
+    },
+    "posterize": {
+        "category": "adjustment",
+        "description": "Reduce color depth (posterize)",
+        "params": {"bits": {"type": "int", "default": 4, "min": 1, "max": 8,
+                            "description": "Bits per channel (fewer = more posterized)"}},
+        "engine": "pillow_ops",
+        "pillow_func": "posterize",
+    },
+    "solarize": {
+        "category": "adjustment",
+        "description": "Solarize effect",
+        "params": {"threshold": {"type": "int", "default": 128, "min": 0, "max": 255,
+                                  "description": "Threshold for inversion"}},
+        "engine": "pillow_ops",
+        "pillow_func": "solarize",
+    },
+    "grayscale": {
+        "category": "adjustment",
+        "description": "Convert to grayscale",
+        "params": {},
+        "engine": "pillow_ops",
+        "pillow_func": "grayscale",
+    },
+    "sepia": {
+        "category": "adjustment",
+        "description": "Apply sepia tone",
+        "params": {"strength": {"type": "float", "default": 0.8, "min": 0.0, "max": 1.0,
+                                "description": "Sepia effect strength"}},
+        "engine": "custom",
+        "custom_func": "apply_sepia",
+    },
+    # Blur & Sharpen
+    "gaussian_blur": {
+        "category": "blur",
+        "description": "Gaussian blur",
+        "params": {"radius": {"type": "float", "default": 2.0, "min": 0.1, "max": 100.0,
+                              "description": "Blur radius in pixels"}},
+        "engine": "pillow_filter",
+        "pillow_filter": "GaussianBlur",
+    },
+    "box_blur": {
+        "category": "blur",
+        "description": "Box blur (uniform average)",
+        "params": {"radius": {"type": "float", "default": 2.0, "min": 0.1, "max": 100.0,
+                              "description": "Blur radius in pixels"}},
+        "engine": "pillow_filter",
+        "pillow_filter": "BoxBlur",
+    },
+    "unsharp_mask": {
+        "category": "blur",
+        "description": "Unsharp mask (sharpen via blur)",
+        "params": {
+            "radius": {"type": "float", "default": 2.0, "min": 0.1, "max": 100.0,
+                       "description": "Blur radius"},
+            "percent": {"type": "int", "default": 150, "min": 1, "max": 500,
+                        "description": "Sharpening strength percent"},
+            "threshold": {"type": "int", "default": 3, "min": 0, "max": 255,
+                          "description": "Minimum brightness change to sharpen"},
+        },
+        "engine": "pillow_filter",
+        "pillow_filter": "UnsharpMask",
+    },
+    "smooth": {
+        "category": "blur",
+        "description": "Smooth (reduce noise)",
+        "params": {},
+        "engine": "pillow_filter",
+        "pillow_filter": "SMOOTH_MORE",
+    },
+    # Stylize
+    "find_edges": {
+        "category": "stylize",
+        "description": "Edge detection",
+        "params": {},
+        "engine": "pillow_filter",
+        "pillow_filter": "FIND_EDGES",
+    },
+    "emboss": {
+        "category": "stylize",
+        "description": "Emboss effect",
+        "params": {},
+        "engine": "pillow_filter",
+        "pillow_filter": "EMBOSS",
+    },
+    "contour": {
+        "category": "stylize",
+        "description": "Contour tracing",
+        "params": {},
+        "engine": "pillow_filter",
+        "pillow_filter": "CONTOUR",
+    },
+    "detail": {
+        "category": "stylize",
+        "description": "Enhance detail",
+        "params": {},
+        "engine": "pillow_filter",
+        "pillow_filter": "DETAIL",
+    },
+    # Transform (applied at render time)
+    "rotate": {
+        "category": "transform",
+        "description": "Rotate layer",
+        "params": {
+            "angle": {"type": "float", "default": 0.0, "min": -360.0, "max": 360.0,
+                      "description": "Rotation angle in degrees"},
+            "expand": {"type": "bool", "default": True,
+                       "description": "Expand canvas to fit rotated image"},
+        },
+        "engine": "pillow_transform",
+        "pillow_method": "rotate",
+    },
+    "flip_h": {
+        "category": "transform",
+        "description": "Flip horizontally",
+        "params": {},
+        "engine": "pillow_transform",
+        "pillow_method": "flip_h",
+    },
+    "flip_v": {
+        "category": "transform",
+        "description": "Flip vertically",
+        "params": {},
+        "engine": "pillow_transform",
+        "pillow_method": "flip_v",
+    },
+    "resize": {
+        "category": "transform",
+        "description": "Resize layer",
+        "params": {
+            "width": {"type": "int", "default": 0, "min": 1, "max": 65535,
+                      "description": "Target width"},
+            "height": {"type": "int", "default": 0, "min": 1, "max": 65535,
+                       "description": "Target height"},
+            "resample": {"type": "str", "default": "lanczos",
+                         "description": "Resampling: nearest, bilinear, bicubic, lanczos"},
+        },
+        "engine": "pillow_transform",
+        "pillow_method": "resize",
+    },
+    "crop": {
+        "category": "transform",
+        "description": "Crop layer",
+        "params": {
+            "left": {"type": "int", "default": 0, "min": 0, "max": 65535},
+            "top": {"type": "int", "default": 0, "min": 0, "max": 65535},
+            "right": {"type": "int", "default": 0, "min": 0, "max": 65535},
+            "bottom": {"type": "int", "default": 0, "min": 0, "max": 65535},
+        },
+        "engine": "pillow_transform",
+        "pillow_method": "crop",
+    },
+}
+
+
+def list_available(category: Optional[str] = None) -> List[Dict[str, Any]]:
+    """List available filters, optionally filtered by category."""
+    result = []
+    for name, info in FILTER_REGISTRY.items():
+        if category and info["category"] != category:
+            continue
+        result.append({
+            "name": name,
+            "category": info["category"],
+            "description": info["description"],
+            "param_count": len(info["params"]),
+        })
+    return result
+
+
+def get_filter_info(name: str) -> Dict[str, Any]:
+    """Get detailed info about a filter."""
+    if name not in FILTER_REGISTRY:
+        raise ValueError(f"Unknown filter: {name}. Use 'filter list-available' to see options.")
+    info = FILTER_REGISTRY[name]
+    return {
+        "name": name,
+        "category": info["category"],
+        "description": info["description"],
+        "params": info["params"],
+        "engine": info["engine"],
+    }
+
+
+def validate_params(name: str, params: Dict[str, Any]) -> Dict[str, Any]:
+    """Validate and fill defaults for filter parameters."""
+    if name not in FILTER_REGISTRY:
+        raise ValueError(f"Unknown filter: {name}")
+
+    spec = FILTER_REGISTRY[name]["params"]
+    result = {}
+
+    for pname, pspec in spec.items():
+        if pname in params:
+            val = params[pname]
+            ptype = pspec["type"]
+            if ptype == "float":
+                val = float(val)
+                if "min" in pspec and val < pspec["min"]:
+                    raise ValueError(f"Parameter '{pname}' minimum is {pspec['min']}, got {val}")
+                if "max" in pspec and val > pspec["max"]:
+                    raise ValueError(f"Parameter '{pname}' maximum is {pspec['max']}, got {val}")
+            elif ptype == "int":
+                val = int(val)
+                if "min" in pspec and val < pspec["min"]:
+                    raise ValueError(f"Parameter '{pname}' minimum is {pspec['min']}, got {val}")
+                if "max" in pspec and val > pspec["max"]:
+                    raise ValueError(f"Parameter '{pname}' maximum is {pspec['max']}, got {val}")
+            elif ptype == "bool":
+                val = str(val).lower() in ("true", "1", "yes")
+            elif ptype == "str":
+                val = str(val)
+            result[pname] = val
+        else:
+            result[pname] = pspec.get("default")
+
+    # Warn about unknown params
+    unknown = set(params.keys()) - set(spec.keys())
+    if unknown:
+        raise ValueError(f"Unknown parameters for filter '{name}': {unknown}")
+
+    return result
+
+
+def add_filter(
+    project: Dict[str, Any],
+    name: str,
+    layer_index: int = 0,
+    params: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Add a filter to a layer."""
+    layers = project.get("layers", [])
+    if layer_index < 0 or layer_index >= len(layers):
+        raise IndexError(f"Layer index {layer_index} out of range (0-{len(layers)-1})")
+
+    if name not in FILTER_REGISTRY:
+        raise ValueError(f"Unknown filter: {name}")
+
+    validated = validate_params(name, params or {})
+
+    filter_entry = {
+        "name": name,
+        "params": validated,
+    }
+
+    layer = layers[layer_index]
+    if "filters" not in layer:
+        layer["filters"] = []
+    layer["filters"].append(filter_entry)
+
+    return filter_entry
+
+
+def remove_filter(
+    project: Dict[str, Any],
+    filter_index: int,
+    layer_index: int = 0,
+) -> Dict[str, Any]:
+    """Remove a filter from a layer by index."""
+    layers = project.get("layers", [])
+    if layer_index < 0 or layer_index >= len(layers):
+        raise IndexError(f"Layer index {layer_index} out of range")
+
+    layer = layers[layer_index]
+    filters = layer.get("filters", [])
+    if filter_index < 0 or filter_index >= len(filters):
+        raise IndexError(f"Filter index {filter_index} out of range (0-{len(filters)-1})")
+
+    return filters.pop(filter_index)
+
+
+def set_filter_param(
+    project: Dict[str, Any],
+    filter_index: int,
+    param: str,
+    value: Any,
+    layer_index: int = 0,
+) -> None:
+    """Set a filter parameter value."""
+    layers = project.get("layers", [])
+    if layer_index < 0 or layer_index >= len(layers):
+        raise IndexError(f"Layer index {layer_index} out of range")
+
+    layer = layers[layer_index]
+    filters = layer.get("filters", [])
+    if filter_index < 0 or filter_index >= len(filters):
+        raise IndexError(f"Filter index {filter_index} out of range")
+
+    filt = filters[filter_index]
+    name = filt["name"]
+    spec = FILTER_REGISTRY[name]["params"]
+
+    if param not in spec:
+        raise ValueError(f"Unknown parameter '{param}' for filter '{name}'. Valid: {list(spec.keys())}")
+
+    # Validate using the spec
+    test_params = dict(filt["params"])
+    test_params[param] = value
+    validated = validate_params(name, test_params)
+    filt["params"] = validated
+
+
+def list_filters(
+    project: Dict[str, Any],
+    layer_index: int = 0,
+) -> List[Dict[str, Any]]:
+    """List filters on a layer."""
+    layers = project.get("layers", [])
+    if layer_index < 0 or layer_index >= len(layers):
+        raise IndexError(f"Layer index {layer_index} out of range")
+
+    layer = layers[layer_index]
+    result = []
+    for i, f in enumerate(layer.get("filters", [])):
+        result.append({
+            "index": i,
+            "name": f["name"],
+            "params": f["params"],
+            "category": FILTER_REGISTRY.get(f["name"], {}).get("category", "unknown"),
+        })
+    return result

package/python/agent-harness/build/lib/cli_anything/gimp/core/layers.py

@@ -0,0 +1,249 @@
+"""GIMP CLI - Layer management module."""
+
+import os
+import copy
+from typing import Dict, Any, List, Optional
+
+
+# Valid blend modes
+BLEND_MODES = [
+    "normal", "multiply", "screen", "overlay", "soft_light", "hard_light",
+    "difference", "darken", "lighten", "color_dodge", "color_burn",
+    "addition", "subtract", "grain_merge", "grain_extract",
+]
+
+
+def add_layer(
+    project: Dict[str, Any],
+    name: str = "New Layer",
+    layer_type: str = "image",
+    source: Optional[str] = None,
+    width: Optional[int] = None,
+    height: Optional[int] = None,
+    fill: str = "transparent",
+    opacity: float = 1.0,
+    blend_mode: str = "normal",
+    position: Optional[int] = None,
+    offset_x: int = 0,
+    offset_y: int = 0,
+) -> Dict[str, Any]:
+    """Add a new layer to the project.
+
+    Args:
+        project: The project dict
+        name: Layer name
+        layer_type: "image", "text", "solid"
+        source: Path to source image file (for image layers)
+        width: Layer width (defaults to canvas width)
+        height: Layer height (defaults to canvas height)
+        fill: Fill type for new layers: "transparent", "white", "black", or hex color
+        opacity: Layer opacity (0.0-1.0)
+        blend_mode: Compositing blend mode
+        position: Insert position (0=top, None=top)
+        offset_x: Horizontal offset from canvas origin
+        offset_y: Vertical offset from canvas origin
+
+    Returns:
+        The new layer dict
+    """
+    if blend_mode not in BLEND_MODES:
+        raise ValueError(f"Invalid blend mode '{blend_mode}'. Valid: {BLEND_MODES}")
+    if not 0.0 <= opacity <= 1.0:
+        raise ValueError(f"Opacity must be 0.0-1.0, got {opacity}")
+    if layer_type not in ("image", "text", "solid"):
+        raise ValueError(f"Invalid layer type '{layer_type}'. Use: image, text, solid")
+    if layer_type == "image" and source and not os.path.exists(source):
+        raise FileNotFoundError(f"Source image not found: {source}")
+
+    canvas = project["canvas"]
+    layer_w = width or canvas["width"]
+    layer_h = height or canvas["height"]
+
+    # Generate next layer ID
+    existing_ids = [l.get("id", 0) for l in project.get("layers", [])]
+    next_id = max(existing_ids, default=-1) + 1
+
+    layer = {
+        "id": next_id,
+        "name": name,
+        "type": layer_type,
+        "width": layer_w,
+        "height": layer_h,
+        "visible": True,
+        "opacity": opacity,
+        "blend_mode": blend_mode,
+        "offset_x": offset_x,
+        "offset_y": offset_y,
+        "filters": [],
+    }
+
+    if layer_type == "image":
+        layer["source"] = source
+        layer["fill"] = fill if not source else None
+    elif layer_type == "solid":
+        layer["fill"] = fill
+    elif layer_type == "text":
+        layer["text"] = ""
+        layer["font"] = "Arial"
+        layer["font_size"] = 24
+        layer["color"] = "#000000"
+
+    if "layers" not in project:
+        project["layers"] = []
+
+    if position is not None:
+        position = max(0, min(position, len(project["layers"])))
+        project["layers"].insert(position, layer)
+    else:
+        project["layers"].insert(0, layer)  # Top of stack
+
+    return layer
+
+
+def add_from_file(
+    project: Dict[str, Any],
+    path: str,
+    name: Optional[str] = None,
+    position: Optional[int] = None,
+    opacity: float = 1.0,
+    blend_mode: str = "normal",
+) -> Dict[str, Any]:
+    """Add a layer from an image file."""
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Image file not found: {path}")
+
+    layer_name = name or os.path.basename(path)
+
+    # Try to get image dimensions
+    try:
+        from PIL import Image
+        with Image.open(path) as img:
+            w, h = img.size
+    except Exception:
+        w = project["canvas"]["width"]
+        h = project["canvas"]["height"]
+
+    return add_layer(
+        project,
+        name=layer_name,
+        layer_type="image",
+        source=os.path.abspath(path),
+        width=w,
+        height=h,
+        opacity=opacity,
+        blend_mode=blend_mode,
+        position=position,
+    )
+
+
+def remove_layer(project: Dict[str, Any], index: int) -> Dict[str, Any]:
+    """Remove a layer by index."""
+    layers = project.get("layers", [])
+    if not layers:
+        raise ValueError("No layers to remove")
+    if index < 0 or index >= len(layers):
+        raise IndexError(f"Layer index {index} out of range (0-{len(layers)-1})")
+    removed = layers.pop(index)
+    return removed
+
+
+def duplicate_layer(project: Dict[str, Any], index: int) -> Dict[str, Any]:
+    """Duplicate a layer."""
+    layers = project.get("layers", [])
+    if index < 0 or index >= len(layers):
+        raise IndexError(f"Layer index {index} out of range (0-{len(layers)-1})")
+
+    original = layers[index]
+    dup = copy.deepcopy(original)
+    existing_ids = [l.get("id", 0) for l in layers]
+    dup["id"] = max(existing_ids, default=-1) + 1
+    dup["name"] = f"{original['name']} copy"
+    layers.insert(index, dup)
+    return dup
+
+
+def move_layer(project: Dict[str, Any], index: int, to: int) -> None:
+    """Move a layer to a new position."""
+    layers = project.get("layers", [])
+    if index < 0 or index >= len(layers):
+        raise IndexError(f"Source layer index {index} out of range")
+    to = max(0, min(to, len(layers) - 1))
+    layer = layers.pop(index)
+    layers.insert(to, layer)
+
+
+def set_layer_property(
+    project: Dict[str, Any], index: int, prop: str, value: Any
+) -> None:
+    """Set a layer property."""
+    layers = project.get("layers", [])
+    if index < 0 or index >= len(layers):
+        raise IndexError(f"Layer index {index} out of range")
+
+    layer = layers[index]
+
+    if prop == "opacity":
+        value = float(value)
+        if not 0.0 <= value <= 1.0:
+            raise ValueError(f"Opacity must be 0.0-1.0, got {value}")
+        layer["opacity"] = value
+    elif prop == "visible":
+        layer["visible"] = str(value).lower() in ("true", "1", "yes")
+    elif prop == "blend_mode" or prop == "mode":
+        if value not in BLEND_MODES:
+            raise ValueError(f"Invalid blend mode '{value}'. Valid: {BLEND_MODES}")
+        layer["blend_mode"] = value
+    elif prop == "name":
+        layer["name"] = str(value)
+    elif prop == "offset_x":
+        layer["offset_x"] = int(value)
+    elif prop == "offset_y":
+        layer["offset_y"] = int(value)
+    else:
+        raise ValueError(f"Unknown property: {prop}. Valid: name, opacity, visible, mode, offset_x, offset_y")
+
+
+def get_layer(project: Dict[str, Any], index: int) -> Dict[str, Any]:
+    """Get a layer by index."""
+    layers = project.get("layers", [])
+    if index < 0 or index >= len(layers):
+        raise IndexError(f"Layer index {index} out of range (0-{len(layers)-1})")
+    return layers[index]
+
+
+def list_layers(project: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """List all layers with summary info."""
+    result = []
+    for i, l in enumerate(project.get("layers", [])):
+        result.append({
+            "index": i,
+            "id": l.get("id", i),
+            "name": l.get("name", f"Layer {i}"),
+            "type": l.get("type", "image"),
+            "visible": l.get("visible", True),
+            "opacity": l.get("opacity", 1.0),
+            "blend_mode": l.get("blend_mode", "normal"),
+            "size": f"{l.get('width', '?')}x{l.get('height', '?')}",
+            "offset": f"({l.get('offset_x', 0)}, {l.get('offset_y', 0)})",
+            "filter_count": len(l.get("filters", [])),
+        })
+    return result
+
+
+def flatten_layers(project: Dict[str, Any]) -> None:
+    """Mark project for flattening (merge all visible layers into one)."""
+    visible = [l for l in project.get("layers", []) if l.get("visible", True)]
+    if not visible:
+        raise ValueError("No visible layers to flatten")
+    # Create a single flattened layer marker
+    project["_flatten_pending"] = True
+
+
+def merge_down(project: Dict[str, Any], index: int) -> None:
+    """Mark layers for merging (layer at index merges into the one below)."""
+    layers = project.get("layers", [])
+    if index < 0 or index >= len(layers):
+        raise IndexError(f"Layer index {index} out of range")
+    if index >= len(layers) - 1:
+        raise ValueError("Cannot merge down the bottom layer")
+    project["_merge_down_pending"] = index