@pixel-normal-edit/mcp 2.0.5 → 2.0.7

package/domains/art-tree/surface_shapes.js

@@ -0,0 +1,87 @@
+const shapes = require('./shapes');
+const shapes3d = require('./3d_shapes');
+
+function drawCupAnalysis(cx, cy, r, h) {
+  const commands = [];
+  const topY = cy - Math.floor(h/2);
+  const botY = cy + Math.floor(h/2);
+  const topRy = Math.floor(r * 0.3);
+  const botRy = Math.floor(r * 0.4);
+
+  // Outer Wall (Convex) - Blue
+  commands.push(shapes.drawLine(cx - r, topY, cx - Math.floor(r*0.8), botY, '#2196f3'));
+  commands.push(shapes.drawLine(cx + r, topY, cx + Math.floor(r*0.8), botY, '#2196f3'));
+  // Base (Flat/Curved)
+  commands.push(shapes.drawEllipse(cx, botY, Math.floor(r*0.8), botRy, '#4caf50', false));
+
+  // Inner Wall (Concave) - Purple
+  // Draw the back half of the inner ellipse (the visible inside of the cup)
+  const innerR = Math.floor(r * 0.9);
+  const innerRy = Math.floor(topRy * 0.9);
+  // Just draw the full inner ellipse but highlighted differently
+  commands.push(shapes.drawEllipse(cx, topY, innerR, innerRy, '#9c27b0', false));
+
+  // Lip / Rim (Transitional edge) - Orange
+  // We represent the lip as the gap between the inner and outer ellipses at the top
+  commands.push(shapes.drawEllipse(cx, topY, r, topRy, '#ff9800', false));
+  
+  // Handle (Tube surface) - Red
+  // Draw a curved handle on the right side
+  const hx = cx + r;
+  const hy = cy;
+  const hr = Math.floor(h * 0.3);
+  // Two nested semi-circles (arcs) for the handle thickness
+  const handleOuter = [];
+  const handleInner = [];
+  for(let i=0; i<=18; i++) {
+    const angle = (i/18) * Math.PI - Math.PI/2; // -90 to 90 degrees
+    handleOuter.push({ x: Math.round(hx + hr * Math.cos(angle)), y: Math.round(hy + hr * Math.sin(angle)) });
+    handleInner.push({ x: Math.round(hx + (hr-5) * Math.cos(angle)), y: Math.round(hy + (hr-5) * Math.sin(angle)) });
+  }
+  commands.push(shapes.drawPolyline(handleOuter, '#f44336'));
+  commands.push(shapes.drawPolyline(handleInner, '#f44336'));
+
+  return commands;
+}
+
+function drawChairAnalysis(cx, cy, w) {
+  const commands = [];
+  const h = Math.floor(w * 1.5);
+  const d = Math.floor(w * 0.8);
+  const seatY = cy;
+  const dx = Math.floor(d * 0.7);
+  const dy = Math.floor(d * 0.5);
+
+  // Seat (Flat plane) - Green
+  const fX = cx - Math.floor(w/2);
+  const bX = fX + dx;
+  const bY = seatY - dy;
+  // Seat wireframe
+  commands.push(shapes.drawRectangle(fX, seatY, w, 10, '#4caf50', false)); // Front thickness
+  commands.push(shapes.drawLine(fX, seatY, bX, bY, '#4caf50'));
+  commands.push(shapes.drawLine(fX+w, seatY, bX+w, bY, '#4caf50'));
+  commands.push(shapes.drawLine(bX, bY, bX+w, bY, '#4caf50'));
+
+  // Backrest (Flat plane + Hard edges) - Blue
+  commands.push(shapes.drawRectangle(bX, bY - Math.floor(h*0.5), w, Math.floor(h*0.5), '#2196f3', false));
+  // Inner rungs (Hard edges)
+  commands.push(shapes.drawRectangle(bX + 10, bY - Math.floor(h*0.4), 5, Math.floor(h*0.4), '#ff9800', false));
+  commands.push(shapes.drawRectangle(bX + w - 15, bY - Math.floor(h*0.4), 5, Math.floor(h*0.4), '#ff9800', false));
+
+  // Legs (Cylindrical surfaces) - Red
+  const legH = Math.floor(h*0.4);
+  const legR = 3;
+  // Front-left
+  commands.push(shapes.drawLine(fX+legR, seatY+10, fX+legR, seatY+10+legH, '#f44336'));
+  commands.push(shapes.drawLine(fX+10-legR, seatY+10, fX+10-legR, seatY+10+legH, '#f44336'));
+  // Front-right
+  commands.push(shapes.drawLine(fX+w-10+legR, seatY+10, fX+w-10+legR, seatY+10+legH, '#f44336'));
+  commands.push(shapes.drawLine(fX+w-legR, seatY+10, fX+w-legR, seatY+10+legH, '#f44336'));
+
+  return commands;
+}
+
+module.exports = {
+  drawCupAnalysis,
+  drawChairAnalysis
+};

package/domains/art-tree/surface_tools.js

@@ -0,0 +1,60 @@
+const { z } = require('zod');
+const { registerTool, sendCommand } = require('../../core/server');
+const surfaceLessons = require('./surface_lessons');
+
+const hexColor = z.string().regex(/^#[0-9a-fA-F]{6}$/).describe('Hex color e.g. #ff0000');
+
+/**
+ * Register all surface analysis tools on the MCP server.
+ * @param {McpServer} server
+ */
+function register(server) {
+  registerTool(server, 'art_tree_lesson_surface_types',
+    'Lesson: Surfaces - Analyze Flat, Convex, and Concave planes',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#2196f3') },
+    async (p) => {
+      const commands = surfaceLessons.lessonSurfaceTypes(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Surface Types lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_edge_types',
+    'Lesson: Surfaces - Analyze Hard vs Soft (Transitional) edges',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#ff5722') },
+    async (p) => {
+      const commands = surfaceLessons.lessonEdgeTypes(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Edge Types lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_surface_cup',
+    'Lesson: Surfaces - Cup Analysis (Real object breakdown)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#607d8b') },
+    async (p) => {
+      const commands = surfaceLessons.lessonCupAnalysis(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Cup Surface Analysis lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_surface_chair',
+    'Lesson: Surfaces - Chair Analysis (Real object breakdown)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#795548') },
+    async (p) => {
+      const commands = surfaceLessons.lessonChairAnalysis(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Chair Surface Analysis lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_surface_catalog',
+    'Get the catalog of all available Surface lessons',
+    {},
+    () => {
+      const catalog = surfaceLessons.getSurfaceLessonCatalog();
+      const text = catalog.map(l =>
+        `  • ${l.id}: ${l.name} — ${l.description}`
+      ).join('\n');
+      return { content: [{ type: 'text', text: `📚 Surface Lessons:\n\n${text}` }] };
+    });
+}
+
+module.exports = { register };

package/domains/art-tree/tools.js

@@ -164,6 +164,60 @@ function register(server) {
       return { content: [{ type: 'text', text: `✓ Bài học tổng hợp hoàn thành (${commands.length} nét vẽ)` }] };
     });
 
+  registerTool(server, 'art_tree_lesson_freehand',
+    'Lesson: Vẽ bằng tay — Luyện vẽ bằng tay, hạn chế dùng thước',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#795548') },
+    async (p) => {
+      const commands = lessons.lessonFreehand(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Bài học vẽ tay hoàn thành (${commands.length} đoạn thẳng nhỏ)` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_proportions',
+    'Lesson: Tỉ lệ và góc — Tập giữ tỉ lệ và góc (Proportions and Angles)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#3f51b5') },
+    async (p) => {
+      const commands = lessons.lessonProportionsAndAngles(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Bài học tỉ lệ và góc hoàn thành` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_curves',
+    'Lesson: Đường cong — Đường cong C, S',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#9c27b0') },
+    async (p) => {
+      const commands = lessons.lessonCurves(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Bài học đường cong C, S hoàn thành (${commands.length} nét)` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_spiral',
+    'Lesson: Xoắn ốc — Vẽ đường xoắn ốc',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#ff9800') },
+    async (p) => {
+      const commands = lessons.lessonSpiral(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Bài học xoắn ốc hoàn thành (${commands.length} nét)` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_strokes',
+    'Lesson: Các loại nét — Nét dài, nét ngắn, nét đậm–nhạt',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#2196f3') },
+    async (p) => {
+      const commands = lessons.lessonStrokes(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Bài học nét vẽ hoàn thành` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_parallel_intersecting',
+    'Lesson: Song song & giao nhau — Vẽ các đường song song và đường giao nhau',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#00bcd4') },
+    async (p) => {
+      const commands = lessons.lessonParallelAndIntersecting(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Bài học song song và giao nhau hoàn thành` }] };
+    });
+
   registerTool(server, 'art_tree_lesson_catalog',
     'Get the catalog of all available Art Tree lessons with descriptions',
     {},

package/domains/art-tree/transform_lessons_1.js

@@ -0,0 +1,108 @@
+const shapes = require('./shapes');
+const transformShapes = require('./transform_shapes');
+const csShapes = require('./cross_section_shapes');
+
+/**
+ * Lesson: Stretch (Elongate)
+ * Sphere -> Egg, Box -> Bar
+ */
+function lessonStretch(canvasSize = 32, color = '#2196f3') {
+  const commands = [];
+  const qX1 = Math.floor(canvasSize * 0.25);
+  const qX2 = Math.floor(canvasSize * 0.75);
+  const cy = Math.floor(canvasSize / 2);
+  const r = Math.floor(canvasSize * 0.15);
+
+  // 1. Stretch: Sphere -> Egg
+  commands.push(shapes.drawCircle(qX1, cy, r, '#bdbdbd', false)); // Original sphere (ghost)
+  commands.push(...transformShapes.drawEgg(qX1, cy, r, color)); // Stretched into egg
+
+  // 2. Stretch: Box -> Bar (Tall)
+  const w = Math.floor(canvasSize * 0.15);
+  // Original box (ghost)
+  commands.push(shapes.drawRectangle(qX2 - w/2, cy - w/2, w, w, '#bdbdbd', false));
+  // Stretched bar
+  commands.push(shapes.drawRectangle(qX2 - w/2, cy - w * 1.5, w, w * 3, '#9c27b0', false));
+
+  return commands;
+}
+
+/**
+ * Lesson: Squash (Compress)
+ * Sphere -> Disk, Box -> Plate
+ */
+function lessonSquash(canvasSize = 32, color = '#ff9800') {
+  const commands = [];
+  const qX1 = Math.floor(canvasSize * 0.25);
+  const qX2 = Math.floor(canvasSize * 0.75);
+  const cy = Math.floor(canvasSize / 2);
+  const r = Math.floor(canvasSize * 0.15);
+
+  // 1. Squash: Sphere -> Disk
+  commands.push(shapes.drawCircle(qX1, cy, r, '#bdbdbd', false)); // Original
+  // Squashed into a flat ellipse/disk
+  commands.push(shapes.drawEllipse(qX1, cy, r * 1.2, Math.floor(r * 0.3), color, false)); 
+
+  // 2. Squash: Box -> Plate
+  const w = Math.floor(canvasSize * 0.2);
+  commands.push(shapes.drawRectangle(qX2 - w/2, cy - w/2, w, w, '#bdbdbd', false)); // Original
+  // Squashed into plate
+  commands.push(shapes.drawRectangle(qX2 - w, cy - Math.floor(w*0.2), w * 2, Math.floor(w*0.4), '#4caf50', false));
+
+  return commands;
+}
+
+/**
+ * Lesson: Taper & Swell (Thu nhỏ hoặc phình to)
+ * Cylinder -> Bottle
+ */
+function lessonTaperSwell(canvasSize = 32, color = '#00bcd4') {
+  const commands = [];
+  const cx = Math.floor(canvasSize / 2);
+  const totalH = Math.floor(canvasSize * 0.8);
+  const topY = Math.floor(canvasSize * 0.1);
+  const bottomY = topY + totalH;
+  const r = Math.floor(canvasSize * 0.25);
+
+  // Original Cylinder (ghost)
+  commands.push(shapes.drawLine(cx - r, topY, cx - r, bottomY, '#bdbdbd'));
+  commands.push(shapes.drawLine(cx + r, topY, cx + r, bottomY, '#bdbdbd'));
+
+  // Tapered and Swelled form (Bottle)
+  const sections = [
+    { y: topY, r: Math.floor(r * 0.3) },         // Neck (Tapered)
+    { y: topY + Math.floor(totalH * 0.4), r: r },// Body (Swelled back to original radius)
+    { y: bottomY, r: Math.floor(r * 0.8) }       // Base (Slightly tapered)
+  ];
+  commands.push(...csShapes.drawLoftedForm(cx, topY, bottomY, sections, color, true));
+
+  return commands;
+}
+
+/**
+ * Lesson: Bend (Uốn cong)
+ * Cylinder -> Bent Tube
+ */
+function lessonBend(canvasSize = 32, color = '#e91e63') {
+  const commands = [];
+  const cx = Math.floor(canvasSize / 2);
+  const cy = Math.floor(canvasSize / 2);
+  const r = Math.floor(canvasSize * 0.1);
+  const length = Math.floor(canvasSize * 0.35);
+
+  // Original straight tube (ghost, pointing right)
+  commands.push(shapes.drawLine(cx, cy - r, cx + length * 2, cy - r, '#bdbdbd'));
+  commands.push(shapes.drawLine(cx, cy + r, cx + length * 2, cy + r, '#bdbdbd'));
+  
+  // Bent tube
+  commands.push(...transformShapes.drawBentTube(cx, cy + length, r, length, color));
+
+  return commands;
+}
+
+module.exports = {
+  lessonStretch,
+  lessonSquash,
+  lessonTaperSwell,
+  lessonBend
+};

package/domains/art-tree/transform_lessons_2.js

@@ -0,0 +1,102 @@
+const shapes = require('./shapes');
+const transformShapes = require('./transform_shapes');
+const structureLessons = require('./structure_lessons');
+
+/**
+ * Lesson: Rotate (Xoay)
+ * Analyzing how objects change when rotated around X, Y, Z axes.
+ * We can reuse the Axis Orientation lesson as it perfectly demonstrates rotation.
+ */
+function lessonRotate(canvasSize = 32, color = '#ff5722') {
+  // Reusing the axis orientation lesson which draws cylinders rotated along X, Y, Z
+  return structureLessons.lessonAxisOrientation(canvasSize, color);
+}
+
+/**
+ * Lesson: Cut (Cắt khối)
+ * Sphere -> Truncated Sphere (exposing internal cross-section)
+ */
+function lessonCut(canvasSize = 32, color = '#8bc34a') {
+  const commands = [];
+  const cx = Math.floor(canvasSize / 2);
+  const cy = Math.floor(canvasSize / 2);
+  const r = Math.floor(canvasSize * 0.35);
+
+  // Original sphere (ghost)
+  commands.push(shapes.drawCircle(cx, cy, r, '#bdbdbd', false));
+  
+  // Cut sphere
+  commands.push(...transformShapes.drawTruncatedSphere(cx, cy, r, color));
+
+  return commands;
+}
+
+/**
+ * Lesson: Hollow (Khoét rỗng)
+ * Cylinder -> Pipe/Hole
+ */
+function lessonHollow(canvasSize = 32, color = '#3f51b5') {
+  const commands = [];
+  const cx = Math.floor(canvasSize / 2);
+  const cy = Math.floor(canvasSize / 2);
+  const outerR = Math.floor(canvasSize * 0.35);
+  const innerR = Math.floor(canvasSize * 0.25);
+  const h = Math.floor(canvasSize * 0.6);
+
+  // Hollow cylinder
+  commands.push(...transformShapes.drawHollowCylinder(cx, cy, outerR, innerR, h, color));
+
+  return commands;
+}
+
+/**
+ * Lesson: Combine (Ghép khối)
+ * Box + Cylinder (e.g., a wheel on an axle, or a tower on a base)
+ */
+function lessonCombine(canvasSize = 32, color = '#607d8b') {
+  const commands = [];
+  const cx = Math.floor(canvasSize / 2);
+  const cy = Math.floor(canvasSize / 2);
+  
+  // 1. Base Box
+  const w = Math.floor(canvasSize * 0.5);
+  const h = Math.floor(canvasSize * 0.2);
+  const d = Math.floor(canvasSize * 0.3);
+  const dx = Math.floor(d * 0.7);
+  const dy = Math.floor(d * 0.5);
+  
+  const fX = cx - Math.floor(w/2);
+  const fY = cy + Math.floor(canvasSize * 0.2);
+  
+  // Front face
+  commands.push(shapes.drawRectangle(fX, fY, w, h, color, false));
+  // Top face (oblique)
+  commands.push(shapes.drawLine(fX, fY, fX + dx, fY - dy, color));
+  commands.push(shapes.drawLine(fX + w, fY, fX + w + dx, fY - dy, color));
+  commands.push(shapes.drawLine(fX + dx, fY - dy, fX + w + dx, fY - dy, color));
+  
+  // 2. Intersecting Cylinder (Tower on top of box)
+  const cylR = Math.floor(canvasSize * 0.15);
+  const cylH = Math.floor(canvasSize * 0.4);
+  const cylX = cx + Math.floor(dx/2);
+  const cylY = fY - Math.floor(dy/2); // Center of the top face
+  
+  // Draw cylinder standing on the box
+  const topY = cylY - cylH;
+  // Top ellipse
+  commands.push(shapes.drawEllipse(cylX, topY, cylR, Math.floor(cylR * 0.3), '#ff9800', false));
+  // Base ellipse (intersecting the box top face)
+  commands.push(shapes.drawEllipse(cylX, cylY, cylR, Math.floor(cylR * 0.3), '#ff9800', false));
+  // Vertical edges
+  commands.push(shapes.drawLine(cylX - cylR, topY, cylX - cylR, cylY, '#ff9800'));
+  commands.push(shapes.drawLine(cylX + cylR, topY, cylX + cylR, cylY, '#ff9800'));
+
+  return commands;
+}
+
+module.exports = {
+  lessonRotate,
+  lessonCut,
+  lessonHollow,
+  lessonCombine
+};

package/domains/art-tree/transform_shapes.js

@@ -0,0 +1,109 @@
+const shapes = require('./shapes');
+const ellipseShapes = require('./ellipse_shapes');
+
+function drawEgg(cx, cy, r, color) {
+  const commands = [];
+  // Approximating an egg by drawing two halves (top stretched, bottom semi-circle)
+  // We'll use multiple ellipses overlapping, or a polygon approximation
+  // Let's use a simpler polygon approximation for the egg contour
+  const points = [];
+  for (let i = 0; i <= 36; i++) {
+    const t = (i / 36) * 2 * Math.PI;
+    const px = r * Math.cos(t);
+    // Stretch the top half
+    const stretch = Math.sin(t) < 0 ? 1.5 : 1.0; 
+    const py = r * Math.sin(t) * stretch;
+    points.push({ x: Math.round(cx + px), y: Math.round(cy + py) });
+  }
+  commands.push(shapes.drawPolyline(points, color));
+  
+  // Add cross contour to show 3D volume
+  commands.push(shapes.drawEllipse(cx, cy + Math.floor(r * 0.2), r, Math.floor(r * 0.3), '#03a9f4', false));
+  return commands;
+}
+
+function drawBentTube(cx, cy, r, length, color) {
+  const commands = [];
+  // Draw a curved tube using a semicircular path
+  const pathR = length; // radius of the bend path
+  // We place ellipses along the arc
+  for (let i = 0; i <= 6; i++) {
+    const angle = (i / 6) * Math.PI; // 0 to 180 degrees
+    const ex = Math.round(cx + pathR * Math.cos(angle));
+    const ey = Math.round(cy - pathR * Math.sin(angle));
+    // Rotate the ellipse to be perpendicular to the path
+    commands.push(...ellipseShapes.drawRotatedEllipse(ex, ey, Math.floor(r * 0.3), r, angle, color));
+  }
+  // Connect inner and outer edges (approximate arcs)
+  const innerPts = [], outerPts = [];
+  for (let i = 0; i <= 18; i++) {
+    const a = (i / 18) * Math.PI;
+    innerPts.push({ x: Math.round(cx + (pathR - r) * Math.cos(a)), y: Math.round(cy - (pathR - r) * Math.sin(a)) });
+    outerPts.push({ x: Math.round(cx + (pathR + r) * Math.cos(a)), y: Math.round(cy - (pathR + r) * Math.sin(a)) });
+  }
+  commands.push(shapes.drawPolyline(innerPts, color));
+  commands.push(shapes.drawPolyline(outerPts, color));
+  
+  return commands;
+}
+
+function drawTruncatedSphere(cx, cy, r, color) {
+  const commands = [];
+  // Sphere outline (partial)
+  const points = [];
+  const cutAngle = Math.PI / 4; // Top section cut off
+  for (let i = 0; i <= 36; i++) {
+    const t = (i / 36) * 2 * Math.PI;
+    // Skip the top part
+    if (t > Math.PI + cutAngle && t < 2 * Math.PI - cutAngle) continue;
+    points.push({ x: Math.round(cx + r * Math.cos(t)), y: Math.round(cy + r * Math.sin(t)) });
+  }
+  commands.push(shapes.drawPolyline(points, color));
+  
+  // Cut surface (ellipse)
+  const cutY = Math.round(cy + r * Math.sin(Math.PI + cutAngle));
+  const cutRx = Math.round(r * Math.cos(cutAngle));
+  const cutRy = Math.floor(cutRx * 0.3);
+  commands.push(shapes.drawEllipse(cx, cutY, cutRx, cutRy, '#ff5722', false)); // Highlight cut surface
+  
+  // Cross contour to reinforce sphere shape
+  commands.push(shapes.drawEllipse(cx, cy + Math.floor(r*0.2), r, Math.floor(r*0.3), '#03a9f4', false));
+  
+  return commands;
+}
+
+function drawHollowCylinder(cx, cy, outerR, innerR, h, color) {
+  const commands = [];
+  const topY = cy - Math.floor(h/2);
+  const botY = cy + Math.floor(h/2);
+  
+  // Outer bottom
+  commands.push(shapes.drawEllipse(cx, botY, outerR, Math.floor(outerR * 0.3), color, false));
+  
+  // Outer top
+  commands.push(shapes.drawEllipse(cx, topY, outerR, Math.floor(outerR * 0.3), color, false));
+  // Inner top (the hole)
+  commands.push(shapes.drawEllipse(cx, topY, innerR, Math.floor(innerR * 0.3), '#e91e63', false));
+  
+  // Inner bottom (visible through hole - rough approximation)
+  // We just draw the back curve of the inner bottom ellipse
+  // For simplicity, we draw the full ellipse but lighter
+  commands.push(shapes.drawEllipse(cx, botY, innerR, Math.floor(innerR * 0.3), '#bdbdbd', false));
+  
+  // Vertical edges
+  commands.push(shapes.drawLine(cx - outerR, topY, cx - outerR, botY, color));
+  commands.push(shapes.drawLine(cx + outerR, topY, cx + outerR, botY, color));
+  
+  // Inner edges (depth)
+  commands.push(shapes.drawLine(cx - innerR, topY, cx - innerR, botY, '#9e9e9e'));
+  commands.push(shapes.drawLine(cx + innerR, topY, cx + innerR, botY, '#9e9e9e'));
+
+  return commands;
+}
+
+module.exports = {
+  drawEgg,
+  drawBentTube,
+  drawTruncatedSphere,
+  drawHollowCylinder
+};

package/domains/art-tree/transform_tools.js

@@ -0,0 +1,104 @@
+const { z } = require('zod');
+const { registerTool, sendCommand } = require('../../core/server');
+const lessons1 = require('./transform_lessons_1');
+const lessons2 = require('./transform_lessons_2');
+
+const hexColor = z.string().regex(/^#[0-9a-fA-F]{6}$/).describe('Hex color e.g. #ff0000');
+
+/**
+ * Register all shape transformation tools on the MCP server.
+ * @param {McpServer} server
+ */
+function register(server) {
+  // --- Scale & Deform ---
+  registerTool(server, 'art_tree_lesson_transform_stretch',
+    'Lesson: Transform - Stretch (Elongate a sphere or box)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#2196f3') },
+    async (p) => {
+      const commands = lessons1.lessonStretch(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Stretch transformation lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_transform_squash',
+    'Lesson: Transform - Squash (Compress a sphere or box)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#ff9800') },
+    async (p) => {
+      const commands = lessons1.lessonSquash(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Squash transformation lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_transform_taper',
+    'Lesson: Transform - Taper/Swell (Cylinder to Bottle)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#00bcd4') },
+    async (p) => {
+      const commands = lessons1.lessonTaperSwell(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Taper/Swell transformation lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_transform_bend',
+    'Lesson: Transform - Bend (Cylinder to curved tube)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#e91e63') },
+    async (p) => {
+      const commands = lessons1.lessonBend(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Bend transformation lesson completed` }] };
+    });
+
+  // --- Boolean & Orientation ---
+  registerTool(server, 'art_tree_lesson_transform_rotate',
+    'Lesson: Transform - Rotate (Analyze rotation around X, Y, Z)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#ff5722') },
+    async (p) => {
+      const commands = lessons2.lessonRotate(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Rotate transformation lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_transform_cut',
+    'Lesson: Transform - Cut (Truncate a sphere)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#8bc34a') },
+    async (p) => {
+      const commands = lessons2.lessonCut(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Cut transformation lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_transform_hollow',
+    'Lesson: Transform - Hollow (Hollow out a cylinder)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#3f51b5') },
+    async (p) => {
+      const commands = lessons2.lessonHollow(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Hollow transformation lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_transform_combine',
+    'Lesson: Transform - Combine (Intersect a box and a cylinder)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#607d8b') },
+    async (p) => {
+      const commands = lessons2.lessonCombine(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Combine transformation lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_transform_catalog',
+    'Get the catalog of all available Transformation lessons',
+    {},
+    () => {
+      const text = `📚 Transformation Lessons:
+  • transform_stretch: Stretch/Elongate (Cầu -> Trứng)
+  • transform_squash: Squash/Compress (Cầu -> Đĩa dẹt)
+  • transform_taper: Taper/Swell (Trụ -> Chai)
+  • transform_bend: Bend (Trụ -> Ống cong)
+  • transform_rotate: Rotate (Xoay 3D)
+  • transform_cut: Cut/Truncate (Cắt khối)
+  • transform_hollow: Hollow out (Khoét rỗng)
+  • transform_combine: Combine (Ghép khối)`;
+      return { content: [{ type: 'text', text }] };
+    });
+}
+
+module.exports = { register };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixel-normal-edit/mcp",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "MCP server for Pixel Normal Edit canvas - enables AI agents to draw pixel art",
   "main": "index.js",
   "bin": {

package/tools/workspace.js

@@ -19,14 +19,24 @@ function register(server) {
     {},
     () => ({ action: 'getActiveTabId' }));
 
-  registerTool(server, 'workspace_create_tab',
+  const { sendCommand } = require('../core/server');
+  server.tool('workspace_create_tab',
     'Create a new blank canvas tab',
     {
       name: z.string().optional().describe('Tab name'),
-      width: z.number().int().default(32).describe('Canvas width'),
-      height: z.number().int().default(32).describe('Canvas height')
+      width: z.number().int().optional().describe('Canvas width'),
+      height: z.number().int().optional().describe('Canvas height')
     },
-    (p) => ({ action: 'createTab', ...p }));
+    async (p) => {
+      if (p.width === undefined || p.height === undefined) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: 'Please provide the width and height dimensions (resize) when creating a new canvas.' }]
+        };
+      }
+      return sendCommand({ action: 'createTab', ...p });
+    }
+  );
 
   registerTool(server, 'workspace_switch_tab',
     'Switch to a different tab by ID (get IDs from workspace_list_tabs)',