psforge 0.2.0__py3-none-any.whl

psforge/tools/filter_tools.py

@@ -0,0 +1,252 @@
+"""Filter tools - gaussian blur, motion blur, sharpen, noise."""
+
+from typing import Any
+
+from loguru import logger
+
+from psforge.decorators import debug_tool, log_tool_call
+from psforge.ps_adapter.application import PhotoshopApp
+from psforge.ps_adapter.utils import validate_numeric_range
+from psforge.registry import register_tool
+
+
+def register(mcp) -> list[str]:
+    """Register all filter tools with MCP server.
+
+    Args:
+        mcp: MCP server instance.
+
+    Returns:
+        List of registered tool names.
+    """
+    registered_tools = []
+
+    @debug_tool
+    @log_tool_call
+    def apply_gaussian_blur(radius: float) -> dict[str, Any]:
+        """Apply Gaussian Blur filter to the currently active layer.
+
+        Args:
+            radius: Blur radius in pixels (0.1-250).
+
+        Returns:
+            dict: Operation result and context.
+        """
+        validate_numeric_range(radius, 0.1, 250, "radius")
+
+        ps_app = PhotoshopApp()
+        doc = ps_app.get_active_document()
+
+        if not doc:
+            return {
+                "success": False,
+                "error": "No active document",
+            }
+
+        try:
+            blur_script = f"""
+            var layer = app.activeDocument.activeLayer;
+            var layerName = layer.name;
+
+            // Apply Gaussian Blur
+            layer.applyGaussianBlur({radius});
+
+            layerName;
+            """
+
+            layer_name = ps_app.execute_javascript(blur_script)
+
+            return {
+                "success": True,
+                "message": f"Applied Gaussian Blur (radius: {radius}px) to layer '{layer_name}'",
+                "layer_name": layer_name,
+                "filter": "Gaussian Blur",
+                "radius": radius,
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to apply Gaussian Blur: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    @debug_tool
+    @log_tool_call
+    def apply_motion_blur(angle: float, radius: int) -> dict[str, Any]:
+        """Apply Motion Blur filter to the currently active layer.
+
+        Args:
+            angle: Blur angle in degrees (-360 to 360).
+            radius: Blur distance in pixels (1-999).
+
+        Returns:
+            dict: Operation result and context.
+        """
+        validate_numeric_range(angle, -360, 360, "angle")
+        validate_numeric_range(radius, 1, 999, "radius")
+
+        ps_app = PhotoshopApp()
+        doc = ps_app.get_active_document()
+
+        if not doc:
+            return {
+                "success": False,
+                "error": "No active document",
+            }
+
+        try:
+            blur_script = f"""
+            var layer = app.activeDocument.activeLayer;
+            var layerName = layer.name;
+
+            // Apply Motion Blur
+            layer.applyMotionBlur({angle}, {radius});
+
+            layerName;
+            """
+
+            layer_name = ps_app.execute_javascript(blur_script)
+
+            return {
+                "success": True,
+                "message": f"Applied Motion Blur (angle: {angle}°, distance: {radius}px) to layer '{layer_name}'",
+                "layer_name": layer_name,
+                "filter": "Motion Blur",
+                "angle": angle,
+                "radius": radius,
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to apply Motion Blur: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    @debug_tool
+    @log_tool_call
+    def apply_sharpen(amount: int, radius: float, threshold: int) -> dict[str, Any]:
+        """Apply Unsharp Mask (USM) sharpening filter to the currently active layer.
+
+        Args:
+            amount: Sharpening amount percentage (1-500).
+            radius: Radius in pixels (0.1-250).
+            threshold: Threshold levels (0-255).
+
+        Returns:
+            dict: Operation result and context.
+        """
+        validate_numeric_range(amount, 1, 500, "amount")
+        validate_numeric_range(radius, 0.1, 250, "radius")
+        validate_numeric_range(threshold, 0, 255, "threshold")
+
+        ps_app = PhotoshopApp()
+        doc = ps_app.get_active_document()
+
+        if not doc:
+            return {
+                "success": False,
+                "error": "No active document",
+            }
+
+        try:
+            sharpen_script = f"""
+            var layer = app.activeDocument.activeLayer;
+            var layerName = layer.name;
+
+            // Apply Unsharp Mask
+            layer.applyUnSharpMask({amount}, {radius}, {threshold});
+
+            layerName;
+            """
+
+            layer_name = ps_app.execute_javascript(sharpen_script)
+
+            return {
+                "success": True,
+                "message": f"Applied Unsharp Mask to layer '{layer_name}'",
+                "layer_name": layer_name,
+                "filter": "Unsharp Mask",
+                "amount": amount,
+                "radius": radius,
+                "threshold": threshold,
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to apply Unsharp Mask: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    @debug_tool
+    @log_tool_call
+    def apply_noise(amount: float, distribution: str = "UNIFORM", monochromatic: bool = False) -> dict[str, Any]:
+        """Apply Add Noise filter to the currently active layer.
+
+        Args:
+            amount: Noise amount percentage (0.1-400).
+            distribution: Noise distribution - UNIFORM or GAUSSIAN (default: UNIFORM).
+            monochromatic: If True, apply noise to tones only without changing colors.
+
+        Returns:
+            dict: Operation result and context.
+        """
+        validate_numeric_range(amount, 0.1, 400, "amount")
+
+        distribution = distribution.upper()
+        if distribution not in ["UNIFORM", "GAUSSIAN"]:
+            return {
+                "success": False,
+                "error": "distribution must be 'UNIFORM' or 'GAUSSIAN'",
+            }
+
+        ps_app = PhotoshopApp()
+        doc = ps_app.get_active_document()
+
+        if not doc:
+            return {
+                "success": False,
+                "error": "No active document",
+            }
+
+        try:
+            mono_js = "true" if monochromatic else "false"
+
+            noise_script = f"""
+            var layer = app.activeDocument.activeLayer;
+            var layerName = layer.name;
+
+            // Apply Add Noise
+            layer.applyAddNoise({amount}, NoiseDistribution.{distribution}, {mono_js});
+
+            layerName;
+            """
+
+            layer_name = ps_app.execute_javascript(noise_script)
+
+            return {
+                "success": True,
+                "message": f"Applied Add Noise ({distribution}, {amount}%) to layer '{layer_name}'",
+                "layer_name": layer_name,
+                "filter": "Add Noise",
+                "amount": amount,
+                "distribution": distribution,
+                "monochromatic": monochromatic,
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to apply Add Noise: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    # Register all tools
+    registered_tools.append(register_tool(mcp, apply_gaussian_blur, "apply_gaussian_blur"))
+    registered_tools.append(register_tool(mcp, apply_motion_blur, "apply_motion_blur"))
+    registered_tools.append(register_tool(mcp, apply_sharpen, "apply_sharpen"))
+    registered_tools.append(register_tool(mcp, apply_noise, "apply_noise"))
+
+    return registered_tools

psforge/tools/history_tools.py

@@ -0,0 +1,241 @@
+"""History tools - undo, redo, get history."""
+
+from typing import Any
+
+from loguru import logger
+
+from psforge.decorators import debug_tool, log_tool_call
+from psforge.ps_adapter.application import PhotoshopApp
+from psforge.ps_adapter.utils import validate_numeric_range
+from psforge.registry import register_tool
+
+
+def register(mcp) -> list[str]:
+    """Register all history tools with MCP server.
+
+    Args:
+        mcp: MCP server instance.
+
+    Returns:
+        List of registered tool names.
+    """
+    registered_tools = []
+
+    @debug_tool
+    @log_tool_call
+    def undo(steps: int = 1) -> dict[str, Any]:
+        """Undo one or more steps in the history.
+
+        Args:
+            steps: Number of steps to undo (default: 1, max: 50).
+
+        Returns:
+            dict: Operation result and context.
+        """
+        validate_numeric_range(steps, 1, 50, "steps")
+
+        ps_app = PhotoshopApp()
+        doc = ps_app.get_active_document()
+
+        if not doc:
+            return {
+                "success": False,
+                "error": "No active document",
+            }
+
+        try:
+            # Undo multiple steps
+            undo_script = f"""
+            var doc = app.activeDocument;
+            var stepsToUndo = {steps};
+            var actualSteps = 0;
+
+            for (var i = 0; i < stepsToUndo; i++) {{
+                try {{
+                    doc.activeHistoryState = doc.activeHistoryState.parent;
+                    actualSteps++;
+                }} catch(e) {{
+                    // No more history to undo
+                    break;
+                }}
+            }}
+
+            JSON.stringify({{
+                steps_undone: actualSteps,
+                current_state: doc.activeHistoryState.name
+            }});
+            """
+
+            import json
+
+            result_str = ps_app.execute_javascript(undo_script)
+            result = json.loads(result_str) if isinstance(result_str, str) else result_str
+
+            return {
+                "success": True,
+                "message": f"Undone {result['steps_undone']} step(s)",
+                "steps_undone": result["steps_undone"],
+                "current_state": result["current_state"],
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to undo: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    @debug_tool
+    @log_tool_call
+    def redo(steps: int = 1) -> dict[str, Any]:
+        """Redo one or more steps in the history.
+
+        Args:
+            steps: Number of steps to redo (default: 1, max: 50).
+
+        Returns:
+            dict: Operation result and context.
+        """
+        validate_numeric_range(steps, 1, 50, "steps")
+
+        ps_app = PhotoshopApp()
+        doc = ps_app.get_active_document()
+
+        if not doc:
+            return {
+                "success": False,
+                "error": "No active document",
+            }
+
+        try:
+            # Note: ExtendScript doesn't have a direct "redo" - we need to navigate forward in history
+            redo_script = f"""
+            var doc = app.activeDocument;
+            var stepsToRedo = {steps};
+            var actualSteps = 0;
+
+            // Get all history states
+            var historyStates = doc.historyStates;
+            var currentIndex = -1;
+
+            // Find current history state index
+            for (var i = 0; i < historyStates.length; i++) {{
+                if (historyStates[i] === doc.activeHistoryState) {{
+                    currentIndex = i;
+                    break;
+                }}
+            }}
+
+            // Move forward in history
+            for (var i = 0; i < stepsToRedo; i++) {{
+                var nextIndex = currentIndex + i + 1;
+                if (nextIndex < historyStates.length) {{
+                    doc.activeHistoryState = historyStates[nextIndex];
+                    actualSteps++;
+                }} else {{
+                    break;
+                }}
+            }}
+
+            JSON.stringify({{
+                steps_redone: actualSteps,
+                current_state: doc.activeHistoryState.name
+            }});
+            """
+
+            import json
+
+            result_str = ps_app.execute_javascript(redo_script)
+            result = json.loads(result_str) if isinstance(result_str, str) else result_str
+
+            return {
+                "success": True,
+                "message": f"Redone {result['steps_redone']} step(s)",
+                "steps_redone": result["steps_redone"],
+                "current_state": result["current_state"],
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to redo: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    @debug_tool
+    @log_tool_call
+    def get_history() -> dict[str, Any]:
+        """Get the list of history states for the active document.
+
+        Returns:
+            dict: Operation result with history states array and context.
+        """
+        ps_app = PhotoshopApp()
+        doc = ps_app.get_active_document()
+
+        if not doc:
+            return {
+                "success": False,
+                "error": "No active document",
+            }
+
+        try:
+            get_history_script = """
+            (function() {
+                var doc = app.activeDocument;
+                var historyStates = doc.historyStates;
+                var currentState = doc.activeHistoryState;
+
+                var states = [];
+                var currentIndex = -1;
+
+                for (var i = 0; i < historyStates.length; i++) {
+                    var state = historyStates[i];
+
+                    if (state === currentState) {
+                        currentIndex = i;
+                    }
+
+                    states.push({
+                        index: i,
+                        name: state.name,
+                        snapshot: state.snapshot,
+                        is_current: (state === currentState)
+                    });
+                }
+
+                return JSON.stringify({
+                    total_states: states.length,
+                    current_index: currentIndex,
+                    current_state: currentState.name,
+                    states: states
+                });
+            })();
+            """
+
+            import json
+
+            result_str = ps_app.execute_javascript(get_history_script)
+            result = json.loads(result_str) if isinstance(result_str, str) else result_str
+
+            return {
+                "success": True,
+                "total_states": result["total_states"],
+                "current_index": result["current_index"],
+                "current_state": result["current_state"],
+                "states": result["states"],
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to get history: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    # Register all tools
+    registered_tools.append(register_tool(mcp, undo, "undo"))
+    registered_tools.append(register_tool(mcp, redo, "redo"))
+    registered_tools.append(register_tool(mcp, get_history, "get_history"))
+
+    return registered_tools

psforge/tools/image_tools.py

@@ -0,0 +1,201 @@
+"""Image tools - place image, get layers info."""
+
+import os
+from typing import Any
+
+from loguru import logger
+
+from psforge.decorators import debug_tool, log_tool_call
+from psforge.ps_adapter.application import PhotoshopApp
+from psforge.registry import register_tool
+
+
+def register(mcp) -> list[str]:
+    """Register all image tools with MCP server.
+
+    Args:
+        mcp: MCP server instance.
+
+    Returns:
+        List of registered tool names.
+    """
+    registered_tools = []
+
+    @debug_tool
+    @log_tool_call
+    def place_image(file_path: str, x: float = 0, y: float = 0) -> dict[str, Any]:
+        """Place an image file into the current document as a new layer.
+
+        Args:
+            file_path: Full path to the image file to place.
+            x: Horizontal position offset in pixels (default: 0).
+            y: Vertical position offset in pixels (default: 0).
+
+        Returns:
+            dict: Operation result with placed layer info and context.
+        """
+        if not os.path.exists(file_path):
+            return {
+                "success": False,
+                "error": f"File not found: {file_path}",
+            }
+
+        ps_app = PhotoshopApp()
+        doc = ps_app.get_active_document()
+
+        if not doc:
+            return {
+                "success": False,
+                "error": "No active document",
+            }
+
+        try:
+            # Convert to Windows path format and escape
+            file_path_escaped = file_path.replace("\\", "\\\\")
+
+            place_script = f"""
+            var doc = app.activeDocument;
+            var fileRef = new File("{file_path_escaped}");
+
+            // Place the file
+            var placedLayer = doc.artLayers.add();
+            doc.activeLayer = placedLayer;
+
+            // Use File.open to place the image
+            var idPlc = charIDToTypeID("Plc ");
+            var desc = new ActionDescriptor();
+            desc.putPath(charIDToTypeID("null"), fileRef);
+            desc.putEnumerated(charIDToTypeID("FTcs"), charIDToTypeID("QCSt"), charIDToTypeID("Qcsa"));
+            var idOfst = charIDToTypeID("Ofst");
+            var offsetDesc = new ActionDescriptor();
+            offsetDesc.putUnitDouble(charIDToTypeID("Hrzn"), charIDToTypeID("#Pxl"), {x});
+            offsetDesc.putUnitDouble(charIDToTypeID("Vrtc"), charIDToTypeID("#Pxl"), {y});
+            desc.putObject(idOfst, idOfst, offsetDesc);
+            executeAction(idPlc, desc, DialogModes.NO);
+
+            doc.activeLayer.name;
+            """
+
+            layer_name = ps_app.execute_javascript(place_script)
+
+            return {
+                "success": True,
+                "message": f"Placed image '{os.path.basename(file_path)}' as layer '{layer_name}'",
+                "layer_name": layer_name,
+                "file_path": file_path,
+                "position": {"x": x, "y": y},
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to place image: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "file_path": file_path,
+            }
+
+    @debug_tool
+    @log_tool_call
+    def get_layers() -> dict[str, Any]:
+        """Get information about all layers in the active document.
+
+        Returns:
+            dict: Operation result with layers array and context.
+        """
+        ps_app = PhotoshopApp()
+        doc = ps_app.get_active_document()
+
+        if not doc:
+            return {
+                "success": False,
+                "error": "No active document",
+            }
+
+        try:
+            get_layers_script = """
+            (function() {
+                var doc = app.activeDocument;
+                var layers = [];
+
+                var layerKindMap = {
+                    1: "NORMAL",
+                    2: "TEXT",
+                    3: "SOLIDFILL",
+                    4: "GRADIENTFILL",
+                    5: "PATTERNFILL",
+                    17: "SMARTOBJECT"
+                };
+
+                function processLayer(layer, index) {
+                    var isBackground = false;
+                    try {
+                        isBackground = layer.isBackgroundLayer;
+                    } catch(e) {}
+
+                    var bounds = {left: 0, top: 0, right: 0, bottom: 0};
+                    try {
+                        bounds = {
+                            left: parseInt(layer.bounds[0]),
+                            top: parseInt(layer.bounds[1]),
+                            right: parseInt(layer.bounds[2]),
+                            bottom: parseInt(layer.bounds[3])
+                        };
+                    } catch(e) {}
+
+                    return {
+                        index: index,
+                        name: layer.name,
+                        kind: layerKindMap[layer.kind] || "UNKNOWN",
+                        visible: layer.visible,
+                        opacity: parseFloat(layer.opacity),
+                        blend_mode: layer.blendMode.toString(),
+                        locked: layer.allLocked || layer.pixelsLocked,
+                        is_background: isBackground,
+                        bounds: bounds,
+                        width: bounds.right - bounds.left,
+                        height: bounds.bottom - bounds.top
+                    };
+                }
+
+                // Get all layers
+                for (var i = 0; i < doc.layers.length; i++) {
+                    layers.push(processLayer(doc.layers[i], i));
+                }
+
+                // Add background layer if exists
+                try {
+                    if (doc.backgroundLayer) {
+                        layers.push(processLayer(doc.backgroundLayer, layers.length));
+                    }
+                } catch(e) {}
+
+                return JSON.stringify({
+                    total_layers: layers.length,
+                    layers: layers
+                });
+            })();
+            """
+
+            import json
+
+            result_str = ps_app.execute_javascript(get_layers_script)
+            result = json.loads(result_str) if isinstance(result_str, str) else result_str
+
+            return {
+                "success": True,
+                "total_layers": result["total_layers"],
+                "layers": result["layers"],
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to get layers: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    # Register all tools
+    registered_tools.append(register_tool(mcp, place_image, "place_image"))
+    registered_tools.append(register_tool(mcp, get_layers, "get_layers"))
+
+    return registered_tools