pixelweaver 0.1.0

package/server/src/pixelweaver/mcp_project_tools.py

@@ -0,0 +1,302 @@
+"""Project and canvas tools for MCP registry."""
+
+from __future__ import annotations
+
+import base64
+from io import BytesIO
+from typing import TYPE_CHECKING, Any
+
+from PIL import Image
+
+from pixelweaver.storage import export_frame_png
+
+if TYPE_CHECKING:
+    from .mcp_registry import MCPCommandRegistry
+
+from .mcp_registry import ToolDef
+
+
+def register_project_tools(registry: MCPCommandRegistry) -> None:
+    """Register all project and canvas MCP tools."""
+
+    # -- Project tools -------------------------------------------------------
+
+    # create_project
+    async def handle_create_project(args: dict[str, Any]) -> dict[str, Any]:
+        name = args["name"]
+        if name in registry.state.projects:
+            return {"success": False, "error": f"Project '{name}' already exists"}
+        project = registry.state.create_project(name, args["width"], args["height"])
+        registry.state.active_project = name
+        return {
+            "success": True,
+            "project": {
+                "name": project.name,
+                "width": project.width,
+                "height": project.height,
+            },
+        }
+
+    registry._register(
+        ToolDef(
+            "create_project",
+            "Create a new pixel art project with the given dimensions",
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "width": {"type": "integer", "minimum": 1, "maximum": 1024},
+                    "height": {"type": "integer", "minimum": 1, "maximum": 1024},
+                },
+                "required": ["name", "width", "height"],
+            },
+            mutates=True,
+        ),
+        handle_create_project,
+    )
+
+    # list_projects
+    async def handle_list_projects(_args: dict[str, Any]) -> dict[str, Any]:
+        names = registry.state.list_projects()
+        return {
+            "success": True,
+            "projects": names,
+            "active": registry.state.active_project,
+        }
+
+    registry._register(
+        ToolDef(
+            "list_projects",
+            "List all projects currently loaded in the server",
+            {"type": "object", "properties": {}},
+            mutates=False,
+        ),
+        handle_list_projects,
+    )
+
+    # open_project
+    async def handle_open_project(args: dict[str, Any]) -> dict[str, Any]:
+        name = args["name"]
+        if name not in registry.state.projects:
+            return {"success": False, "error": f"Project '{name}' not found"}
+        registry.state.active_project = name
+        return {"success": True, "active_project": name}
+
+    registry._register(
+        ToolDef(
+            "open_project",
+            "Set a project as the active project",
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                },
+                "required": ["name"],
+            },
+            mutates=True,
+        ),
+        handle_open_project,
+    )
+
+    # save_project
+    async def handle_save_project(_args: dict[str, Any]) -> dict[str, Any]:
+        project = registry.state.get_active_project()
+        if project is None:
+            return {"success": False, "error": "No active project"}
+        # Use the shared data dir (set by CLI --data-dir)
+        from pixelweaver.config import get_data_dir
+        from pixelweaver.storage import save_project
+
+        save_project(project, get_data_dir())
+        return {"success": True, "saved": project.name}
+
+    registry._register(
+        ToolDef(
+            "save_project",
+            "Persist the current project to disk immediately",
+            {"type": "object", "properties": {}},
+            mutates=False,
+        ),
+        handle_save_project,
+    )
+
+    # get_project_info
+    async def handle_get_project_info(_args: dict[str, Any]) -> dict[str, Any]:
+        project = registry.state.get_active_project()
+        if project is None:
+            return {"success": False, "error": "No active project"}
+        return {
+            "success": True,
+            "name": project.name,
+            "width": project.width,
+            "height": project.height,
+            "canvas_count": len(project.canvases),
+            "canvases": list(project.canvases.keys()),
+            "history_length": len(project.command_history),
+        }
+
+    registry._register(
+        ToolDef(
+            "get_project_info",
+            "Get metadata about the active project (name, dimensions, canvas count)",
+            {"type": "object", "properties": {}},
+            mutates=False,
+        ),
+        handle_get_project_info,
+    )
+
+    # -- Canvas tools --------------------------------------------------------
+
+    # get_canvas_size
+    async def handle_get_canvas_size(_args: dict[str, Any]) -> dict[str, Any]:
+        project = registry.state.get_active_project()
+        if project is None:
+            return {"success": False, "error": "No active project"}
+        canvas = next(iter(project.canvases.values()), None)
+        if canvas is None:
+            return {"success": False, "error": "No canvas in project"}
+        return {
+            "success": True,
+            "width": canvas.width,
+            "height": canvas.height,
+        }
+
+    registry._register(
+        ToolDef(
+            "get_canvas_size",
+            "Get the dimensions of the active canvas",
+            {"type": "object", "properties": {}},
+            mutates=False,
+        ),
+        handle_get_canvas_size,
+    )
+
+    # resize_canvas
+    async def handle_resize_canvas(args: dict[str, Any]) -> dict[str, Any]:
+        err = registry._require_active_project()
+        if err:
+            return err
+        return await registry._dispatch_command("resize_canvas", args)
+
+    registry._register(
+        ToolDef(
+            "resize_canvas",
+            "Resize the active canvas",
+            {
+                "type": "object",
+                "properties": {
+                    "width": {"type": "integer", "minimum": 1, "maximum": 4096},
+                    "height": {"type": "integer", "minimum": 1, "maximum": 4096},
+                    "anchor": {
+                        "type": "string",
+                        "enum": [
+                            "top-left", "top-center", "top-right",
+                            "center-left", "center", "center-right",
+                            "bottom-left", "bottom-center", "bottom-right",
+                        ],
+                        "default": "top-left",
+                    },
+                },
+                "required": ["width", "height"],
+            },
+            mutates=True,
+        ),
+        handle_resize_canvas,
+    )
+
+    # get_pixel
+    async def handle_get_pixel(args: dict[str, Any]) -> dict[str, Any]:
+        project = registry.state.get_active_project()
+        if project is None:
+            return {"success": False, "error": "No active project"}
+
+        canvas = next(iter(project.canvases.values()), None)
+        if canvas is None:
+            return {"success": False, "error": "No canvas in project"}
+
+        x, y = args["x"], args["y"]
+        if x < 0 or x >= canvas.width or y < 0 or y >= canvas.height:
+            return {"success": False, "error": f"Coordinates ({x}, {y}) out of bounds"}
+
+        layer_id = args.get("layer_id")
+        if layer_id is None and canvas.layers:
+            layer_id = canvas.layers[0]["id"]
+
+        if layer_id is None or layer_id not in canvas.current_frame().pixel_data:
+            return {"success": False, "error": f"Layer '{layer_id}' not found"}
+
+        data = canvas.current_frame().pixel_data[layer_id]
+        offset = (y * canvas.width + x) * 4
+        r, g, b, a = data[offset], data[offset + 1], data[offset + 2], data[offset + 3]
+        return {
+            "success": True,
+            "x": x,
+            "y": y,
+            "color": f"#{r:02x}{g:02x}{b:02x}{a:02x}",
+            "rgba": [r, g, b, a],
+        }
+
+    registry._register(
+        ToolDef(
+            "get_pixel",
+            "Get the RGBA color of a pixel at the given coordinates",
+            {
+                "type": "object",
+                "properties": {
+                    "x": {"type": "integer"},
+                    "y": {"type": "integer"},
+                    "layer_id": {
+                        "type": "string",
+                        "description": "Layer to read from (default: first layer)",
+                    },
+                },
+                "required": ["x", "y"],
+            },
+            mutates=False,
+        ),
+        handle_get_pixel,
+    )
+
+    # get_region
+    async def handle_get_region(args: dict[str, Any]) -> dict[str, Any]:
+        project = registry.state.get_active_project()
+        if project is None:
+            return {"success": False, "error": "No active project"}
+
+        canvas = next(iter(project.canvases.values()), None)
+        if canvas is None:
+            return {"success": False, "error": "No canvas in project"}
+
+        # Composite visible layers for the region
+        try:
+            png_bytes = export_frame_png(project, canvas.name)
+            # Load the composited image to extract the region
+            img = Image.open(BytesIO(png_bytes))
+            x, y, w, h = args["x"], args["y"], args["width"], args["height"]
+            region = img.crop((x, y, x + w, y + h))
+            buf = BytesIO()
+            region.save(buf, format="PNG")
+            b64 = base64.b64encode(buf.getvalue()).decode("ascii")
+        except Exception as exc:
+            return {"success": False, "error": str(exc)}
+
+        return {"success": True, "image_base64": b64, "width": w, "height": h}
+
+    registry._register(
+        ToolDef(
+            "get_region",
+            "Get a base64 PNG of a rectangular region of the canvas",
+            {
+                "type": "object",
+                "properties": {
+                    "x": {"type": "integer"},
+                    "y": {"type": "integer"},
+                    "width": {"type": "integer"},
+                    "height": {"type": "integer"},
+                },
+                "required": ["x", "y", "width", "height"],
+            },
+            mutates=False,
+        ),
+        handle_get_region,
+    )

package/server/src/pixelweaver/mcp_read_tools.py

@@ -0,0 +1,163 @@
+"""Read/introspection tools for MCP registry."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pixelweaver.storage import export_frame_png, make_thumbnail_base64
+
+if TYPE_CHECKING:
+    from .mcp_registry import MCPCommandRegistry
+
+from .mcp_registry import ToolDef
+
+
+def register_read_tools(registry: MCPCommandRegistry) -> None:
+    """Register all read/introspection MCP tools."""
+
+    # get_canvas_info
+    async def handle_get_canvas_info(_args: dict[str, Any]) -> dict[str, Any]:
+        project = registry.state.get_active_project()
+        if project is None:
+            return {"success": False, "error": "No active project"}
+
+        canvases_info = []
+        for name, canvas in project.canvases.items():
+            canvases_info.append({
+                "name": name,
+                "width": canvas.width,
+                "height": canvas.height,
+                "layer_count": len(canvas.layers),
+                "frame_count": canvas.frame_count,
+                "current_frame_index": canvas.current_frame_index,
+                "global_fps": canvas.global_fps,
+            })
+
+        return {"success": True, "canvases": canvases_info}
+
+    registry._register(
+        ToolDef(
+            "get_canvas_info",
+            "Get canvas size, layer count, and frame count for the active project",
+            {"type": "object", "properties": {}},
+            mutates=False,
+        ),
+        handle_get_canvas_info,
+    )
+
+    # get_layer_tree
+    async def handle_get_layer_tree(_args: dict[str, Any]) -> dict[str, Any]:
+        project = registry.state.get_active_project()
+        if project is None:
+            return {"success": False, "error": "No active project"}
+
+        canvas = next(iter(project.canvases.values()), None)
+        if canvas is None:
+            return {"success": False, "error": "No canvas in project"}
+
+        layers = [
+            {
+                "id": layer["id"],
+                "name": layer.get("name", "Unnamed"),
+                "visible": layer.get("visible", True),
+                "opacity": layer.get("opacity", 1.0),
+                "has_data": layer["id"] in canvas.current_frame().pixel_data,
+            }
+            for layer in canvas.layers
+        ]
+
+        return {"success": True, "layers": layers}
+
+    registry._register(
+        ToolDef(
+            "get_layer_tree",
+            "Get the layer structure of the active canvas",
+            {"type": "object", "properties": {}},
+            mutates=False,
+        ),
+        handle_get_layer_tree,
+    )
+
+    # get_palette
+    async def handle_get_palette(args: dict[str, Any]) -> dict[str, Any]:
+        project = registry.state.get_active_project()
+        if project is None:
+            return {"success": False, "error": "No active project"}
+
+        canvas = next(iter(project.canvases.values()), None)
+        if canvas is None:
+            return {"success": False, "error": "No canvas in project"}
+
+        max_colors = args.get("max_colors", 64)
+        colors: set[str] = set()
+
+        for layer in canvas.layers:
+            data = canvas.current_frame().pixel_data.get(layer["id"])
+            if data is None:
+                continue
+            # Sample pixels to find unique colors
+            for i in range(0, len(data), 4):
+                r, g, b, a = data[i], data[i + 1], data[i + 2], data[i + 3]
+                if a > 0:  # Skip fully transparent pixels
+                    colors.add(f"#{r:02x}{g:02x}{b:02x}{a:02x}")
+                if len(colors) >= max_colors:
+                    break
+            if len(colors) >= max_colors:
+                break
+
+        return {"success": True, "colors": sorted(colors)}
+
+    registry._register(
+        ToolDef(
+            "get_palette",
+            "Get the colors currently used on the active canvas",
+            {
+                "type": "object",
+                "properties": {
+                    "max_colors": {"type": "integer", "default": 64},
+                },
+            },
+            mutates=False,
+        ),
+        handle_get_palette,
+    )
+
+    # get_canvas_thumbnail
+    async def handle_get_canvas_thumbnail(args: dict[str, Any]) -> dict[str, Any]:
+        project = registry.state.get_active_project()
+        if project is None:
+            return {"success": False, "error": "No active project"}
+
+        canvas = next(iter(project.canvases.values()), None)
+        if canvas is None:
+            return {"success": False, "error": "No canvas in project"}
+
+        max_size = args.get("max_size", 256)
+
+        # Use the composited export, then downscale via the shared helper.
+        try:
+            png_bytes = export_frame_png(project, canvas.name)
+            b64 = make_thumbnail_base64(png_bytes, max_size=max_size)
+        except Exception as exc:
+            return {"success": False, "error": str(exc)}
+
+        return {"success": True, "image_base64": b64}
+
+    registry._register(
+        ToolDef(
+            "get_canvas_thumbnail",
+            "Get a base64 PNG thumbnail of the active canvas",
+            {
+                "type": "object",
+                "properties": {
+                    "max_size": {
+                        "type": "integer",
+                        "default": 256,
+                        "description": "Max dimension in pixels",
+                    },
+                },
+            },
+            mutates=False,
+        ),
+        handle_get_canvas_thumbnail,
+    )