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

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

@@ -0,0 +1,174 @@
+"""GIMP CLI - Media file analysis module."""
+
+import os
+import json
+import subprocess
+from typing import Dict, Any, Optional
+
+
+def probe_image(path: str) -> Dict[str, Any]:
+    """Analyze an image file and return metadata."""
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Image file not found: {path}")
+
+    from PIL import Image
+
+    info = {
+        "path": os.path.abspath(path),
+        "filename": os.path.basename(path),
+        "file_size": os.path.getsize(path),
+        "file_size_human": _human_size(os.path.getsize(path)),
+    }
+
+    try:
+        with Image.open(path) as img:
+            info["width"] = img.width
+            info["height"] = img.height
+            info["mode"] = img.mode
+            info["format"] = img.format
+            info["format_description"] = img.format_description if hasattr(img, 'format_description') else img.format
+            info["megapixels"] = f"{img.width * img.height / 1_000_000:.2f}"
+
+            # DPI info
+            dpi = img.info.get("dpi")
+            if dpi:
+                info["dpi"] = {"x": round(dpi[0]), "y": round(dpi[1])}
+
+            # Animation info (GIF, APNG)
+            info["is_animated"] = getattr(img, "is_animated", False)
+            if info["is_animated"]:
+                info["n_frames"] = getattr(img, "n_frames", 1)
+
+            # Color palette
+            if img.mode == "P":
+                palette = img.getpalette()
+                info["palette_colors"] = len(palette) // 3 if palette else 0
+
+            # EXIF data (basic)
+            exif = img.getexif()
+            if exif:
+                exif_data = {}
+                tag_names = {
+                    271: "Make", 272: "Model", 274: "Orientation",
+                    305: "Software", 306: "DateTime",
+                    36867: "DateTimeOriginal", 37378: "ApertureValue",
+                    33434: "ExposureTime", 34855: "ISOSpeedRatings",
+                }
+                for tag_id, name in tag_names.items():
+                    if tag_id in exif:
+                        exif_data[name] = str(exif[tag_id])
+                if exif_data:
+                    info["exif"] = exif_data
+
+            # Image bands/channels
+            info["channels"] = len(img.getbands())
+            info["bands"] = list(img.getbands())
+
+            # Bits per pixel estimation
+            bits_per_channel = {"1": 1, "L": 8, "P": 8, "RGB": 8, "RGBA": 8,
+                                "CMYK": 8, "I": 32, "F": 32, "LA": 8}
+            bpc = bits_per_channel.get(img.mode, 8)
+            info["bits_per_pixel"] = bpc * info["channels"]
+
+    except Exception as e:
+        info["error"] = str(e)
+
+    return info
+
+
+def list_media_in_project(project: Dict[str, Any]) -> list:
+    """List all media files referenced in the project."""
+    media = []
+    for i, layer in enumerate(project.get("layers", [])):
+        source = layer.get("source")
+        if source:
+            exists = os.path.exists(source)
+            media.append({
+                "layer_index": i,
+                "layer_name": layer.get("name", f"Layer {i}"),
+                "source": source,
+                "exists": exists,
+            })
+    return media
+
+
+def check_media(project: Dict[str, Any]) -> Dict[str, Any]:
+    """Check that all referenced media files exist."""
+    media = list_media_in_project(project)
+    missing = [m for m in media if not m["exists"]]
+    return {
+        "total": len(media),
+        "found": len(media) - len(missing),
+        "missing": len(missing),
+        "missing_files": [m["source"] for m in missing],
+        "status": "ok" if not missing else "missing_files",
+    }
+
+
+def get_image_histogram(path: str) -> Dict[str, Any]:
+    """Get histogram data for an image."""
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Image file not found: {path}")
+
+    from PIL import Image
+
+    with Image.open(path) as img:
+        if img.mode not in ("RGB", "RGBA", "L"):
+            img = img.convert("RGB")
+
+        hist = img.histogram()
+
+        if img.mode in ("RGB", "RGBA"):
+            r_hist = hist[0:256]
+            g_hist = hist[256:512]
+            b_hist = hist[512:768]
+            return {
+                "mode": img.mode,
+                "channels": {
+                    "red": {"min": _first_nonzero(r_hist), "max": _last_nonzero(r_hist),
+                            "mean": _hist_mean(r_hist)},
+                    "green": {"min": _first_nonzero(g_hist), "max": _last_nonzero(g_hist),
+                              "mean": _hist_mean(g_hist)},
+                    "blue": {"min": _first_nonzero(b_hist), "max": _last_nonzero(b_hist),
+                             "mean": _hist_mean(b_hist)},
+                },
+            }
+        else:
+            return {
+                "mode": img.mode,
+                "channels": {
+                    "luminance": {"min": _first_nonzero(hist), "max": _last_nonzero(hist),
+                                  "mean": _hist_mean(hist)},
+                },
+            }
+
+
+def _human_size(nbytes: int) -> str:
+    """Convert byte count to human-readable string."""
+    for unit in ("B", "KB", "MB", "GB"):
+        if nbytes < 1024:
+            return f"{nbytes:.1f} {unit}"
+        nbytes /= 1024
+    return f"{nbytes:.1f} TB"
+
+
+def _first_nonzero(hist: list) -> int:
+    for i, v in enumerate(hist):
+        if v > 0:
+            return i
+    return 0
+
+
+def _last_nonzero(hist: list) -> int:
+    for i in range(len(hist) - 1, -1, -1):
+        if hist[i] > 0:
+            return i
+    return 0
+
+
+def _hist_mean(hist: list) -> float:
+    total = sum(hist)
+    if total == 0:
+        return 0.0
+    weighted = sum(i * v for i, v in enumerate(hist))
+    return round(weighted / total, 1)

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

@@ -0,0 +1,131 @@
+"""GIMP CLI - Core project management module."""
+
+import json
+import os
+import copy
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+
+
+# Default canvas profiles
+PROFILES = {
+    "hd1080p": {"width": 1920, "height": 1080, "dpi": 72},
+    "hd720p": {"width": 1280, "height": 720, "dpi": 72},
+    "4k": {"width": 3840, "height": 2160, "dpi": 72},
+    "square1080": {"width": 1080, "height": 1080, "dpi": 72},
+    "a4_300dpi": {"width": 2480, "height": 3508, "dpi": 300},
+    "a4_150dpi": {"width": 1240, "height": 1754, "dpi": 150},
+    "letter_300dpi": {"width": 2550, "height": 3300, "dpi": 300},
+    "web_banner": {"width": 1200, "height": 628, "dpi": 72},
+    "instagram_post": {"width": 1080, "height": 1080, "dpi": 72},
+    "instagram_story": {"width": 1080, "height": 1920, "dpi": 72},
+    "twitter_header": {"width": 1500, "height": 500, "dpi": 72},
+    "youtube_thumb": {"width": 1280, "height": 720, "dpi": 72},
+    "icon_256": {"width": 256, "height": 256, "dpi": 72},
+    "icon_512": {"width": 512, "height": 512, "dpi": 72},
+}
+
+PROJECT_VERSION = "1.0"
+
+
+def create_project(
+    width: int = 1920,
+    height: int = 1080,
+    color_mode: str = "RGB",
+    background: str = "#ffffff",
+    dpi: int = 72,
+    name: str = "untitled",
+    profile: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Create a new GIMP CLI project."""
+    if profile and profile in PROFILES:
+        p = PROFILES[profile]
+        width = p["width"]
+        height = p["height"]
+        dpi = p["dpi"]
+
+    if color_mode not in ("RGB", "RGBA", "L", "LA"):
+        raise ValueError(f"Invalid color mode: {color_mode}. Use RGB, RGBA, L, or LA.")
+    if width < 1 or height < 1:
+        raise ValueError(f"Canvas dimensions must be positive: {width}x{height}")
+    if dpi < 1:
+        raise ValueError(f"DPI must be positive: {dpi}")
+
+    project = {
+        "version": PROJECT_VERSION,
+        "name": name,
+        "canvas": {
+            "width": width,
+            "height": height,
+            "color_mode": color_mode,
+            "background": background,
+            "dpi": dpi,
+        },
+        "layers": [],
+        "selection": None,
+        "guides": [],
+        "metadata": {
+            "created": datetime.now().isoformat(),
+            "modified": datetime.now().isoformat(),
+            "software": "gimp-cli 1.0",
+        },
+    }
+    return project
+
+
+def open_project(path: str) -> Dict[str, Any]:
+    """Open a .gimp-cli.json project file."""
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Project file not found: {path}")
+    with open(path, "r") as f:
+        project = json.load(f)
+    if "version" not in project or "canvas" not in project:
+        raise ValueError(f"Invalid project file: {path}")
+    return project
+
+
+def save_project(project: Dict[str, Any], path: str) -> str:
+    """Save project to a .gimp-cli.json file."""
+    project["metadata"]["modified"] = datetime.now().isoformat()
+    with open(path, "w") as f:
+        json.dump(project, f, indent=2, default=str)
+    return path
+
+
+def get_project_info(project: Dict[str, Any]) -> Dict[str, Any]:
+    """Get summary information about the project."""
+    canvas = project["canvas"]
+    layers = project.get("layers", [])
+    return {
+        "name": project.get("name", "untitled"),
+        "version": project.get("version", "unknown"),
+        "canvas": {
+            "width": canvas["width"],
+            "height": canvas["height"],
+            "color_mode": canvas.get("color_mode", "RGB"),
+            "background": canvas.get("background", "#ffffff"),
+            "dpi": canvas.get("dpi", 72),
+        },
+        "layer_count": len(layers),
+        "layers": [
+            {
+                "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"),
+                "filter_count": len(l.get("filters", [])),
+            }
+            for i, l in enumerate(layers)
+        ],
+        "metadata": project.get("metadata", {}),
+    }
+
+
+def list_profiles() -> List[Dict[str, Any]]:
+    """List all available canvas profiles."""
+    result = []
+    for name, p in PROFILES.items():
+        result.append({"name": name, "width": p["width"], "height": p["height"], "dpi": p["dpi"]})
+    return result

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

@@ -0,0 +1,130 @@
+"""GIMP CLI - Session management with undo/redo."""
+
+import json
+import os
+import copy
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+
+
+class Session:
+    """Manages project state with undo/redo history."""
+
+    MAX_UNDO = 50
+
+    def __init__(self):
+        self.project: Optional[Dict[str, Any]] = None
+        self.project_path: Optional[str] = None
+        self._undo_stack: List[Dict[str, Any]] = []
+        self._redo_stack: List[Dict[str, Any]] = []
+        self._modified: bool = False
+
+    def has_project(self) -> bool:
+        return self.project is not None
+
+    def get_project(self) -> Dict[str, Any]:
+        if self.project is None:
+            raise RuntimeError("No project loaded. Use 'project new' or 'project open' first.")
+        return self.project
+
+    def set_project(self, project: Dict[str, Any], path: Optional[str] = None) -> None:
+        self.project = project
+        self.project_path = path
+        self._undo_stack.clear()
+        self._redo_stack.clear()
+        self._modified = False
+
+    def snapshot(self, description: str = "") -> None:
+        """Save current state to undo stack before a mutation."""
+        if self.project is None:
+            return
+        state = {
+            "project": copy.deepcopy(self.project),
+            "description": description,
+            "timestamp": datetime.now().isoformat(),
+        }
+        self._undo_stack.append(state)
+        if len(self._undo_stack) > self.MAX_UNDO:
+            self._undo_stack.pop(0)
+        self._redo_stack.clear()
+        self._modified = True
+
+    def undo(self) -> Optional[str]:
+        """Undo the last operation. Returns description of undone action."""
+        if not self._undo_stack:
+            raise RuntimeError("Nothing to undo.")
+        if self.project is None:
+            raise RuntimeError("No project loaded.")
+
+        # Save current state to redo stack
+        self._redo_stack.append({
+            "project": copy.deepcopy(self.project),
+            "description": "redo point",
+            "timestamp": datetime.now().isoformat(),
+        })
+
+        # Restore previous state
+        state = self._undo_stack.pop()
+        self.project = state["project"]
+        self._modified = True
+        return state.get("description", "")
+
+    def redo(self) -> Optional[str]:
+        """Redo the last undone operation."""
+        if not self._redo_stack:
+            raise RuntimeError("Nothing to redo.")
+        if self.project is None:
+            raise RuntimeError("No project loaded.")
+
+        # Save current state to undo stack
+        self._undo_stack.append({
+            "project": copy.deepcopy(self.project),
+            "description": "undo point",
+            "timestamp": datetime.now().isoformat(),
+        })
+
+        # Restore redo state
+        state = self._redo_stack.pop()
+        self.project = state["project"]
+        self._modified = True
+        return state.get("description", "")
+
+    def status(self) -> Dict[str, Any]:
+        """Get session status."""
+        return {
+            "has_project": self.project is not None,
+            "project_path": self.project_path,
+            "modified": self._modified,
+            "undo_count": len(self._undo_stack),
+            "redo_count": len(self._redo_stack),
+            "project_name": self.project.get("name", "untitled") if self.project else None,
+        }
+
+    def save_session(self, path: Optional[str] = None) -> str:
+        """Save the session state (project + undo history) to disk."""
+        if self.project is None:
+            raise RuntimeError("No project to save.")
+
+        save_path = path or self.project_path
+        if not save_path:
+            raise ValueError("No save path specified.")
+
+        # Save project
+        self.project["metadata"]["modified"] = datetime.now().isoformat()
+        with open(save_path, "w") as f:
+            json.dump(self.project, f, indent=2, default=str)
+
+        self.project_path = save_path
+        self._modified = False
+        return save_path
+
+    def list_history(self) -> List[Dict[str, str]]:
+        """List undo history."""
+        result = []
+        for i, state in enumerate(reversed(self._undo_stack)):
+            result.append({
+                "index": i,
+                "description": state.get("description", ""),
+                "timestamp": state.get("timestamp", ""),
+            })
+        return result