pixelweaver 0.1.0

package/server/src/pixelweaver/mcp_bridge.py

@@ -0,0 +1,189 @@
+"""MCP Bridge -- HTTP client that forwards MCP state to/from the collab server.
+
+Instead of the MCP server managing its own isolated state, every tool
+execution round-trips through the collaboration server's REST API:
+
+  1. Before execution: pull the latest state from the collab server
+  2. Execute the tool against the local (synced) state
+  3. After execution: push the modified state back, triggering a
+     broadcast to all WebSocket clients (the frontend)
+
+This ensures the collab server remains the single source of truth and
+that every MCP mutation is visible to the frontend in real time.
+
+The collab server must be running on COLLAB_SERVER_URL for MCP to work.
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+from typing import Any
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+COLLAB_SERVER_URL = "http://localhost:7779"
+
+# Reusable client -- created lazily, lives for the process lifetime.
+# The MCP stdio server is single-threaded so no concurrency concerns.
+_client: httpx.AsyncClient | None = None
+
+
+def _get_client() -> httpx.AsyncClient:
+    """Return (and lazily create) the shared HTTP client."""
+    global _client
+    if _client is None:
+        _client = httpx.AsyncClient(base_url=COLLAB_SERVER_URL, timeout=30.0)
+    return _client
+
+
+class CollabServerUnreachableError(Exception):
+    """Raised when the collab server is not reachable."""
+
+
+async def health_check() -> bool:
+    """Return True if the collab server is reachable."""
+    try:
+        resp = await _get_client().get("/health")
+        return resp.status_code == 200
+    except httpx.HTTPError:
+        return False
+
+
+async def pull_full_state() -> dict[str, Any]:
+    """Fetch full serialized state from the collab server.
+
+    Returns the dict produced by GET /api/state/full.
+    Raises CollabServerUnreachableError if the server cannot be reached.
+    """
+    try:
+        resp = await _get_client().get("/api/state/full")
+        resp.raise_for_status()
+        return resp.json()
+    except httpx.HTTPError as exc:
+        raise CollabServerUnreachableError(
+            f"Cannot reach collab server at {COLLAB_SERVER_URL}: {exc}"
+        ) from exc
+
+
+async def push_full_state(state_dict: dict[str, Any]) -> None:
+    """Push full serialized state to the collab server and trigger broadcast.
+
+    Sends POST /api/state/sync with the full state payload.
+    Raises CollabServerUnreachableError if the server cannot be reached.
+    """
+    try:
+        resp = await _get_client().post("/api/state/sync", json=state_dict)
+        resp.raise_for_status()
+    except httpx.HTTPError as exc:
+        raise CollabServerUnreachableError(
+            f"Cannot reach collab server at {COLLAB_SERVER_URL}: {exc}"
+        ) from exc
+
+
+def serialize_state(state: Any) -> dict[str, Any]:
+    """Serialize a ServerState into a dict suitable for push_full_state.
+
+    Includes pixel data as base64-encoded strings so the JSON payload
+    stays valid (raw bytes are not JSON-serializable).
+    """
+    projects: dict[str, Any] = {}
+    for name, project in state.projects.items():
+        canvases: dict[str, Any] = {}
+        for cname, canvas in project.canvases.items():
+            layers_serialized = [dict(layer) for layer in canvas.layers]
+            # Serialize ALL frames with their per-layer pixel data
+            frames_serialized = [
+                {
+                    "id": frame.id,
+                    "duration_ms": frame.duration_ms,
+                    "pixel_data": {
+                        layer_id: base64.b64encode(data).decode("ascii")
+                        for layer_id, data in frame.pixel_data.items()
+                    },
+                }
+                for frame in canvas.frames
+            ]
+            canvases[cname] = {
+                "name": canvas.name,
+                "width": canvas.width,
+                "height": canvas.height,
+                "layers": layers_serialized,
+                "frames": frames_serialized,
+                "current_frame_index": canvas.current_frame_index,
+                "global_fps": canvas.global_fps,
+            }
+        projects[name] = {
+            "name": project.name,
+            "width": project.width,
+            "height": project.height,
+            "canvases": canvases,
+            "command_history": project.command_history,
+            "redo_stack": project.redo_stack,
+        }
+    return {
+        "projects": projects,
+        "active_project": state.active_project,
+    }
+
+
+def deserialize_into_state(state: Any, data: dict[str, Any]) -> None:
+    """Overwrite a ServerState's contents from a serialized dict.
+
+    Inverse of serialize_state: restores projects, canvases, layers,
+    pixel data, and history from the dict pulled from the collab server.
+    """
+    import uuid
+
+    from pixelweaver.state import CanvasState, FrameState, ProjectState
+
+    state.projects.clear()
+    state.active_project = data.get("active_project")
+
+    for name, pdata in data.get("projects", {}).items():
+        project = ProjectState(
+            name=pdata["name"],
+            width=pdata["width"],
+            height=pdata["height"],
+            command_history=pdata.get("command_history", []),
+            redo_stack=pdata.get("redo_stack", []),
+        )
+        for cname, cdata in pdata.get("canvases", {}).items():
+            # Reconstruct frames from serialized data
+            if "frames" in cdata:
+                # New format: full frame list with per-frame pixel data
+                frames: list[FrameState] = []
+                for fdata in cdata["frames"]:
+                    pixel_data: dict[str, bytes] = {
+                        lid: base64.b64decode(b64)
+                        for lid, b64 in fdata.get("pixel_data", {}).items()
+                    }
+                    frames.append(FrameState(
+                        id=fdata["id"],
+                        duration_ms=fdata.get("duration_ms"),
+                        pixel_data=pixel_data,
+                    ))
+            else:
+                # Legacy format: flat pixel_data dict, single frame
+                pixel_data_legacy: dict[str, bytes] = {
+                    lid: base64.b64decode(b64)
+                    for lid, b64 in cdata.get("pixel_data", {}).items()
+                }
+                frames = [FrameState(
+                    id=str(uuid.uuid4()),
+                    pixel_data=pixel_data_legacy,
+                )]
+
+            canvas = CanvasState(
+                name=cdata["name"],
+                width=cdata["width"],
+                height=cdata["height"],
+                layers=cdata.get("layers", []),
+                frames=frames,
+                current_frame_index=cdata.get("current_frame_index", 0),
+                global_fps=cdata.get("global_fps", 12.0),
+            )
+            project.canvases[cname] = canvas
+        state.projects[name] = project

package/server/src/pixelweaver/mcp_drawing_tools.py

@@ -0,0 +1,178 @@
+"""Drawing tools for MCP registry."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .mcp_registry import MCPCommandRegistry
+
+
+def register_drawing_tools(registry: MCPCommandRegistry) -> None:
+    """Register all drawing-related MCP tools."""
+    drawing_tools = [
+        ("draw_pixels", "Draw pixels at specified coordinates with a given color", {
+            "type": "object",
+            "properties": {
+                "pixels": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "x": {"type": "integer"},
+                            "y": {"type": "integer"},
+                        },
+                        "required": ["x", "y"],
+                    },
+                    "description": "Array of {x, y} pixel positions",
+                },
+                "color": {
+                    "type": "string",
+                    "description": "RGBA hex color, e.g. '#ff0000ff'",
+                },
+                "layer_id": {"type": "string", "description": "Target layer ID"},
+            },
+            "required": ["pixels", "color"],
+        }),
+        ("erase_pixels", "Erase pixels at specified coordinates (set to transparent)", {
+            "type": "object",
+            "properties": {
+                "pixels": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "x": {"type": "integer"},
+                            "y": {"type": "integer"},
+                        },
+                        "required": ["x", "y"],
+                    },
+                },
+                "layer_id": {"type": "string"},
+            },
+            "required": ["pixels"],
+        }),
+        ("flood_fill", "Fill a contiguous area with a color starting from a seed point", {
+            "type": "object",
+            "properties": {
+                "x": {"type": "integer", "description": "Seed X coordinate"},
+                "y": {"type": "integer", "description": "Seed Y coordinate"},
+                "color": {"type": "string", "description": "Fill color (RGBA hex)"},
+                "tolerance": {
+                    "type": "integer",
+                    "description": "Color match tolerance (0-255)",
+                    "default": 0,
+                },
+                "layer_id": {"type": "string"},
+            },
+            "required": ["x", "y", "color"],
+        }),
+        ("draw_line", "Draw a line between two points", {
+            "type": "object",
+            "properties": {
+                "x1": {"type": "integer"},
+                "y1": {"type": "integer"},
+                "x2": {"type": "integer"},
+                "y2": {"type": "integer"},
+                "color": {"type": "string"},
+                "thickness": {"type": "integer", "default": 1},
+                "layer_id": {"type": "string"},
+            },
+            "required": ["x1", "y1", "x2", "y2", "color"],
+        }),
+        ("draw_rect", "Draw a rectangle (filled or outline)", {
+            "type": "object",
+            "properties": {
+                "x": {"type": "integer"},
+                "y": {"type": "integer"},
+                "width": {"type": "integer"},
+                "height": {"type": "integer"},
+                "color": {"type": "string"},
+                "filled": {"type": "boolean", "default": True},
+                "layer_id": {"type": "string"},
+            },
+            "required": ["x", "y", "width", "height", "color"],
+        }),
+        ("draw_ellipse", "Draw an ellipse (filled or outline)", {
+            "type": "object",
+            "properties": {
+                "cx": {"type": "integer", "description": "Center X"},
+                "cy": {"type": "integer", "description": "Center Y"},
+                "rx": {"type": "integer", "description": "Radius X"},
+                "ry": {"type": "integer", "description": "Radius Y"},
+                "color": {"type": "string"},
+                "filled": {"type": "boolean", "default": True},
+                "layer_id": {"type": "string"},
+            },
+            "required": ["cx", "cy", "rx", "ry", "color"],
+        }),
+        ("draw_diamond", "Draw a diamond shape", {
+            "type": "object",
+            "properties": {
+                "cx": {"type": "integer", "description": "Center X"},
+                "cy": {"type": "integer", "description": "Center Y"},
+                "rx": {"type": "integer", "description": "Half-width"},
+                "ry": {"type": "integer", "description": "Half-height"},
+                "color": {"type": "string"},
+                "filled": {"type": "boolean", "default": True},
+                "layer_id": {"type": "string"},
+            },
+            "required": ["cx", "cy", "rx", "ry", "color"],
+        }),
+        ("draw_gradient", "Draw a gradient between two colors", {
+            "type": "object",
+            "properties": {
+                "x": {"type": "integer"},
+                "y": {"type": "integer"},
+                "width": {"type": "integer"},
+                "height": {"type": "integer"},
+                "color_start": {"type": "string"},
+                "color_end": {"type": "string"},
+                "direction": {
+                    "type": "string",
+                    "enum": ["horizontal", "vertical", "diagonal"],
+                    "default": "horizontal",
+                },
+                "layer_id": {"type": "string"},
+            },
+            "required": ["x", "y", "width", "height", "color_start", "color_end"],
+        }),
+        ("draw_noise", "Fill a region with random noise", {
+            "type": "object",
+            "properties": {
+                "x": {"type": "integer"},
+                "y": {"type": "integer"},
+                "width": {"type": "integer"},
+                "height": {"type": "integer"},
+                "colors": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Palette of colors to sample from",
+                },
+                "density": {"type": "number", "default": 0.5, "description": "0.0-1.0"},
+                "layer_id": {"type": "string"},
+            },
+            "required": ["x", "y", "width", "height", "colors"],
+        }),
+        ("draw_dither", "Apply a dither pattern between two colors", {
+            "type": "object",
+            "properties": {
+                "x": {"type": "integer"},
+                "y": {"type": "integer"},
+                "width": {"type": "integer"},
+                "height": {"type": "integer"},
+                "color_a": {"type": "string"},
+                "color_b": {"type": "string"},
+                "pattern": {
+                    "type": "string",
+                    "enum": ["checker", "ordered", "bayer"],
+                    "default": "checker",
+                },
+                "layer_id": {"type": "string"},
+            },
+            "required": ["x", "y", "width", "height", "color_a", "color_b"],
+        }),
+    ]
+
+    for name, desc, schema in drawing_tools:
+        registry._register_drawing_tool(name, desc, schema)

package/server/src/pixelweaver/mcp_export_tools.py

@@ -0,0 +1,291 @@
+"""Export and curated high-level 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_export_tools(registry: MCPCommandRegistry) -> None:
+    """Register all export and curated high-level MCP tools."""
+
+    # -- Export tools ---------------------------------------------------------
+
+    # export_png
+    async def handle_export_png(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_name = args.get("canvas_name")
+        if canvas_name is None:
+            canvas_name = next(iter(project.canvases.keys()), None)
+        if canvas_name is None:
+            return {"success": False, "error": "No canvas in project"}
+
+        try:
+            png_bytes = export_frame_png(project, canvas_name)
+            b64 = base64.b64encode(png_bytes).decode("ascii")
+        except ValueError as exc:
+            return {"success": False, "error": str(exc)}
+
+        return {"success": True, "image_base64": b64, "format": "png"}
+
+    registry._register(
+        ToolDef(
+            "export_png",
+            "Export the active canvas as a composited PNG (returns base64)",
+            {
+                "type": "object",
+                "properties": {
+                    "canvas_name": {
+                        "type": "string",
+                        "description": "Canvas to export (default: first canvas)",
+                    },
+                },
+            },
+            mutates=False,
+        ),
+        handle_export_png,
+    )
+
+    # export_spritesheet
+    async def handle_export_spritesheet(args: dict[str, Any]) -> dict[str, Any]:
+        project = registry.state.get_active_project()
+        if project is None:
+            return {"success": False, "error": "No active project"}
+
+        if not project.canvases:
+            return {"success": False, "error": "No canvases in project"}
+
+        canvas_name = args.get("canvas_name")
+        if canvas_name is None:
+            canvas_name = next(iter(project.canvases.keys()), None)
+        if canvas_name is None:
+            return {"success": False, "error": "No canvas in project"}
+
+        canvas = project.canvases.get(canvas_name)
+        if canvas is None:
+            return {"success": False, "error": f"Canvas {canvas_name!r} not found"}
+
+        direction = args.get("direction", "horizontal")
+
+        # Iterate animation frames within a single canvas and composite
+        # each frame's layers into a spritesheet strip.
+        frame_images: list[Image.Image] = []
+        try:
+            for i in range(canvas.frame_count):
+                png_bytes = export_frame_png(project, canvas_name, frame=i)
+                frame_images.append(Image.open(BytesIO(png_bytes)))
+        except (ValueError, IndexError) as exc:
+            return {"success": False, "error": str(exc)}
+
+        if not frame_images:
+            return {"success": False, "error": "No frames to export"}
+
+        # Build the spritesheet from all composited frames
+        frame_count = len(frame_images)
+        fw, fh = frame_images[0].width, frame_images[0].height
+
+        if direction == "vertical":
+            sheet = Image.new("RGBA", (fw, fh * frame_count), (0, 0, 0, 0))
+            for i, img in enumerate(frame_images):
+                sheet.paste(img, (0, i * fh))
+        else:
+            sheet = Image.new("RGBA", (fw * frame_count, fh), (0, 0, 0, 0))
+            for i, img in enumerate(frame_images):
+                sheet.paste(img, (i * fw, 0))
+
+        buf = BytesIO()
+        sheet.save(buf, format="PNG")
+        b64 = base64.b64encode(buf.getvalue()).decode("ascii")
+
+        return {
+            "success": True,
+            "image_base64": b64,
+            "format": "png",
+            "frame_count": frame_count,
+            "direction": direction,
+            "frame_width": fw,
+            "frame_height": fh,
+        }
+
+    registry._register(
+        ToolDef(
+            "export_spritesheet",
+            "Export all animation frames of a canvas as a spritesheet (returns base64 PNG)",
+            {
+                "type": "object",
+                "properties": {
+                    "canvas_name": {
+                        "type": "string",
+                        "description": "Canvas to export (default: first canvas)",
+                    },
+                    "direction": {
+                        "type": "string",
+                        "enum": ["horizontal", "vertical"],
+                        "description": "Layout direction (default: horizontal)",
+                    },
+                },
+            },
+            mutates=False,
+        ),
+        handle_export_spritesheet,
+    )
+
+    # -- Curated high-level tools --------------------------------------------
+
+    # draw_shape: combines rect/ellipse/diamond/line
+    async def handle_draw_shape(args: dict[str, Any]) -> dict[str, Any]:
+        err = registry._require_active_project()
+        if err:
+            return err
+
+        shape = args["shape"]
+        params = {k: v for k, v in args.items() if k != "shape"}
+
+        # Map shape names to the underlying command types
+        shape_to_cmd = {
+            "rect": "draw_rect",
+            "ellipse": "draw_ellipse",
+            "diamond": "draw_diamond",
+            "line": "draw_line",
+        }
+        cmd_type = shape_to_cmd.get(shape)
+        if cmd_type is None:
+            return {"success": False, "error": f"Unknown shape: {shape}"}
+
+        # Remap generic x/y/width/height to shape-specific params
+        if shape == "line":
+            params = {
+                "x1": args["x"],
+                "y1": args["y"],
+                "x2": args["width"],
+                "y2": args["height"],
+                "color": args["color"],
+                "layer_id": args.get("layer_id"),
+            }
+            # Remove None values
+            params = {k: v for k, v in params.items() if v is not None}
+        elif shape in ("ellipse", "diamond"):
+            params = {
+                "cx": args["x"],
+                "cy": args["y"],
+                "rx": args["width"],
+                "ry": args["height"],
+                "color": args["color"],
+                "filled": args.get("filled", True),
+                "layer_id": args.get("layer_id"),
+            }
+            params = {k: v for k, v in params.items() if v is not None}
+
+        return await registry._dispatch_command(cmd_type, params)
+
+    registry._register(
+        ToolDef(
+            "draw_shape",
+            "Draw a shape (rect, ellipse, diamond, or line) on the canvas",
+            {
+                "type": "object",
+                "properties": {
+                    "shape": {
+                        "type": "string",
+                        "enum": ["rect", "ellipse", "diamond", "line"],
+                    },
+                    "x": {"type": "integer", "description": "X (or x1 for line)"},
+                    "y": {"type": "integer", "description": "Y (or y1 for line)"},
+                    "width": {"type": "integer", "description": "Width (or x2 for line)"},
+                    "height": {"type": "integer", "description": "Height (or y2 for line)"},
+                    "color": {"type": "string"},
+                    "filled": {"type": "boolean", "default": True},
+                    "layer_id": {"type": "string"},
+                },
+                "required": ["shape", "x", "y", "width", "height", "color"],
+            },
+            mutates=True,
+        ),
+        handle_draw_shape,
+    )
+
+    # fill_area: flood_fill with tolerance
+    async def handle_fill_area(args: dict[str, Any]) -> dict[str, Any]:
+        err = registry._require_active_project()
+        if err:
+            return err
+        return await registry._dispatch_command("flood_fill", args)
+
+    registry._register(
+        ToolDef(
+            "fill_area",
+            "Fill a contiguous area starting from a seed point, with optional tolerance",
+            {
+                "type": "object",
+                "properties": {
+                    "x": {"type": "integer"},
+                    "y": {"type": "integer"},
+                    "color": {"type": "string"},
+                    "tolerance": {"type": "integer", "default": 0},
+                    "layer_id": {"type": "string"},
+                },
+                "required": ["x", "y", "color"],
+            },
+            mutates=True,
+        ),
+        handle_fill_area,
+    )
+
+    # apply_effect
+    async def handle_apply_effect(args: dict[str, Any]) -> dict[str, Any]:
+        err = registry._require_active_project()
+        if err:
+            return err
+        return await registry._dispatch_command("apply_effect", args)
+
+    registry._register(
+        ToolDef(
+            "apply_effect",
+            "Apply a visual effect to the canvas or a region",
+            {
+                "type": "object",
+                "properties": {
+                    "effect": {
+                        "type": "string",
+                        "enum": [
+                            "blur", "sharpen", "invert", "grayscale",
+                            "brightness", "contrast", "hue_shift",
+                            "outline", "shadow", "pixelate",
+                        ],
+                    },
+                    "intensity": {
+                        "type": "number",
+                        "default": 1.0,
+                        "description": "Effect strength (0.0 - 10.0)",
+                    },
+                    "region": {
+                        "type": "object",
+                        "properties": {
+                            "x": {"type": "integer"},
+                            "y": {"type": "integer"},
+                            "width": {"type": "integer"},
+                            "height": {"type": "integer"},
+                        },
+                        "description": "Optional bounding region; omit for full canvas",
+                    },
+                    "layer_id": {"type": "string"},
+                },
+                "required": ["effect"],
+            },
+            mutates=True,
+        ),
+        handle_apply_effect,
+    )