@pixel-normal-edit/mcp 2.0.6 → 2.0.8

package/domains/art-tree/structure_shapes.js

@@ -0,0 +1,74 @@
+const shapes = require('./shapes');
+const ellipseShapes = require('./ellipse_shapes');
+
+/**
+ * Draw a 3D coordinate system (X, Y, Z axes) originating from a center point
+ */
+function drawXYZAxes(cx, cy, length) {
+  const commands = [];
+  
+  // Y-axis (Vertical) - Green
+  commands.push(shapes.drawLine(cx, cy, cx, cy - length, '#4caf50'));
+  
+  // X-axis (Horizontal) - Red
+  commands.push(shapes.drawLine(cx, cy, cx + length, cy, '#f44336'));
+  
+  // Z-axis (Depth - Oblique projection) - Blue
+  const dx = Math.floor(length * 0.7 * Math.cos(Math.PI / 6));
+  const dy = Math.floor(length * 0.7 * Math.sin(Math.PI / 6));
+  commands.push(shapes.drawLine(cx, cy, cx - dx, cy + dy, '#2196f3'));
+
+  // Center point
+  commands.push(shapes.drawCircle(cx, cy, 2, '#000000', true));
+
+  return commands;
+}
+
+/**
+ * Draw a complex bottle structure using cross-sections and central axis
+ */
+function drawBottleAnatomy(cx, cy, totalHeight, color) {
+  const commands = [];
+  
+  const bottomY = cy + Math.floor(totalHeight / 2);
+  const topY = cy - Math.floor(totalHeight / 2);
+  
+  // Central vertical axis
+  commands.push(shapes.drawLine(cx, topY - 10, cx, bottomY + 10, '#bdbdbd'));
+  
+  // Define cross sections (y position from bottom, radius)
+  const sections = [
+    { y: bottomY, r: Math.floor(totalHeight * 0.2) },                     // Base
+    { y: bottomY - Math.floor(totalHeight * 0.4), r: Math.floor(totalHeight * 0.2) },   // Body
+    { y: bottomY - Math.floor(totalHeight * 0.7), r: Math.floor(totalHeight * 0.08) },  // Neck start
+    { y: topY, r: Math.floor(totalHeight * 0.08) }                        // Mouth
+  ];
+  
+  // Draw cross section ellipses
+  for (const sec of sections) {
+    // ry is based on perspective (lower = wider perspective, but keep it simple here)
+    const ry = Math.floor(sec.r * 0.3);
+    commands.push(shapes.drawEllipse(cx, sec.y, sec.r, ry, color, false));
+    
+    // Cross point on the axis
+    commands.push(shapes.drawCircle(cx, sec.y, 1, '#ff0000', true));
+  }
+  
+  // Draw outer contour lines
+  for (let i = 0; i < sections.length - 1; i++) {
+    const s1 = sections[i];
+    const s2 = sections[i+1];
+    
+    // Left contour
+    commands.push(shapes.drawLine(cx - s1.r, s1.y, cx - s2.r, s2.y, color));
+    // Right contour
+    commands.push(shapes.drawLine(cx + s1.r, s1.y, cx + s2.r, s2.y, color));
+  }
+  
+  return commands;
+}
+
+module.exports = {
+  drawXYZAxes,
+  drawBottleAnatomy
+};

package/domains/art-tree/structure_tools.js

@@ -0,0 +1,51 @@
+const { z } = require('zod');
+const { registerTool, sendCommand } = require('../../core/server');
+const structureLessons = require('./structure_lessons');
+
+const hexColor = z.string().regex(/^#[0-9a-fA-F]{6}$/).describe('Hex color e.g. #ff0000');
+
+/**
+ * Register all structure and axis tools on the MCP server.
+ * @param {McpServer} server
+ */
+function register(server) {
+  registerTool(server, 'art_tree_lesson_structure_xyz',
+    'Lesson: Structure - XYZ Axes (Vertical, Horizontal, Depth directions)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#2196f3') },
+    async (p) => {
+      const commands = structureLessons.lessonXYZAxes(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ XYZ Axes lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_structure_bottle',
+    'Lesson: Structure - Complex Analysis (Bottle with cross-sections)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#9c27b0') },
+    async (p) => {
+      const commands = structureLessons.lessonComplexStructure(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Complex Structure (Bottle) lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_structure_orientation',
+    'Lesson: Structure - Axis Orientation (Which axis is it oriented along?)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#00bcd4') },
+    async (p) => {
+      const commands = structureLessons.lessonAxisOrientation(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Axis Orientation lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_structure_catalog',
+    'Get the catalog of all available Structure lessons',
+    {},
+    () => {
+      const catalog = structureLessons.getStructureLessonCatalog();
+      const text = catalog.map(l =>
+        `  • ${l.id}: ${l.name} — ${l.description}`
+      ).join('\n');
+      return { content: [{ type: 'text', text: `📚 Structure Lessons:\n\n${text}` }] };
+    });
+}
+
+module.exports = { register };

package/domains/art-tree/surface_lessons.js

@@ -0,0 +1,112 @@
+const shapes = require('./shapes');
+const surfaceShapes = require('./surface_shapes');
+
+/**
+ * Lesson: Surface Types (Flat, convex, concave)
+ */
+function lessonSurfaceTypes(canvasSize = 32, color = '#2196f3') {
+  const commands = [];
+  const midY = Math.floor(canvasSize / 2);
+  const qX = Math.floor(canvasSize / 4);
+  const r = Math.floor(canvasSize * 0.15);
+
+  // 1. Flat Plane
+  const w = Math.floor(canvasSize * 0.2);
+  commands.push(shapes.drawRectangle(qX - w/2, midY - w/2, w, w, '#4caf50', false));
+  // Add some grid lines to show it's flat
+  commands.push(shapes.drawLine(qX, midY - w/2, qX, midY + w/2, '#4caf50'));
+  commands.push(shapes.drawLine(qX - w/2, midY, qX + w/2, midY, '#4caf50'));
+
+  // 2. Convex Surface (e.g. Dome/Sphere)
+  // We use an ellipse that curves outwards (downwards)
+  commands.push(shapes.drawEllipse(qX * 2, midY, r, r, '#ff9800', false));
+  // Cross contour curving DOWN (convex towards viewer)
+  commands.push(shapes.drawEllipse(qX * 2, midY + Math.floor(r*0.2), r, Math.floor(r*0.3), '#ff9800', false));
+
+  // 3. Concave Surface (e.g. Bowl)
+  // Draw the top rim of a bowl
+  commands.push(shapes.drawEllipse(qX * 3, midY, r, Math.floor(r*0.3), '#9c27b0', false));
+  // Draw the bottom curve (the inside of the bowl)
+  const bowlPoints = [];
+  for(let i=0; i<=18; i++) {
+    const a = (i/18) * Math.PI; // 0 to 180 degrees (bottom half)
+    bowlPoints.push({ x: Math.round(qX * 3 + r * Math.cos(a)), y: Math.round(midY + r * Math.sin(a)) });
+  }
+  commands.push(shapes.drawPolyline(bowlPoints, '#9c27b0'));
+
+  return commands;
+}
+
+/**
+ * Lesson: Edge Types (Hard sharp corners vs Soft rounded edges)
+ */
+function lessonEdgeTypes(canvasSize = 32, color = '#ff5722') {
+  const commands = [];
+  const qX1 = Math.floor(canvasSize * 0.3);
+  const qX2 = Math.floor(canvasSize * 0.7);
+  const midY = Math.floor(canvasSize / 2);
+  const w = Math.floor(canvasSize * 0.25);
+
+  // 1. Hard Edge (Sharp corners)
+  commands.push(shapes.drawRectangle(qX1 - w/2, midY - w/2, w, w, '#e91e63', false));
+
+  // 2. Soft Edge / Transitional
+  // Draw a box with rounded corners (fillet)
+  const r = Math.floor(w * 0.2); // Corner radius
+  const rx = qX2 - w/2;
+  const ry = midY - w/2;
+  
+  // Straight segments
+  commands.push(shapes.drawLine(rx + r, ry, rx + w - r, ry, '#00bcd4')); // Top
+  commands.push(shapes.drawLine(rx + w, ry + r, rx + w, ry + w - r, '#00bcd4')); // Right
+  commands.push(shapes.drawLine(rx + r, ry + w, rx + w - r, ry + w, '#00bcd4')); // Bottom
+  commands.push(shapes.drawLine(rx, ry + r, rx, ry + w - r, '#00bcd4')); // Left
+  
+  // Rounded corners (approximated with small circles for visual simplicity)
+  commands.push(shapes.drawCircle(rx + r, ry + r, r, '#00bcd4', false)); // TL
+  commands.push(shapes.drawCircle(rx + w - r, ry + r, r, '#00bcd4', false)); // TR
+  commands.push(shapes.drawCircle(rx + w - r, ry + w - r, r, '#00bcd4', false)); // BR
+  commands.push(shapes.drawCircle(rx + r, ry + w - r, r, '#00bcd4', false)); // BL
+
+  return commands;
+}
+
+/**
+ * Lesson: Cup Analysis (Analyzing surfaces of a cup)
+ */
+function lessonCupAnalysis(canvasSize = 32, color = '#607d8b') {
+  const cx = Math.floor(canvasSize / 2);
+  const cy = Math.floor(canvasSize / 2);
+  const r = Math.floor(canvasSize * 0.2);
+  const h = Math.floor(canvasSize * 0.4);
+
+  return surfaceShapes.drawCupAnalysis(cx, cy, r, h);
+}
+
+/**
+ * Lesson: Chair Analysis (Analyzing surfaces and edges of a chair)
+ */
+function lessonChairAnalysis(canvasSize = 32, color = '#795548') {
+  const cx = Math.floor(canvasSize / 2);
+  const cy = Math.floor(canvasSize / 2);
+  const w = Math.floor(canvasSize * 0.3);
+
+  return surfaceShapes.drawChairAnalysis(cx, cy, w);
+}
+
+function getSurfaceLessonCatalog() {
+  return [
+    { id: 'surface_types', name: 'Surface Types', description: 'Flat, Convex, Concave planes', fn: lessonSurfaceTypes },
+    { id: 'edge_types', name: 'Edge Types', description: 'Hard vs Soft (Transitional) edges', fn: lessonEdgeTypes },
+    { id: 'surface_cup', name: 'Cup Analysis', description: 'Real object: Convex/Concave walls, Rim, Tube handle', fn: lessonCupAnalysis },
+    { id: 'surface_chair', name: 'Chair Analysis', description: 'Real object: Flat planes, Hard edges, Cylindrical legs', fn: lessonChairAnalysis },
+  ];
+}
+
+module.exports = {
+  lessonSurfaceTypes,
+  lessonEdgeTypes,
+  lessonCupAnalysis,
+  lessonChairAnalysis,
+  getSurfaceLessonCatalog
+};

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

@@ -96,72 +96,126 @@ function register(server) {
   // ── Lesson Tools ──────────────────────────────────────────────────────
 
   registerTool(server, 'art_tree_lesson_lines',
-    'Lesson: Vẽ đường thẳng — Introduction to drawing straight lines',
+    'Lesson: Lines — Introduction to drawing straight lines',
     { canvasSize: z.number().int().min(16).max(64).default(32),
       color: hexColor.default('#ff0000') },
     async (p) => {
       const commands = lessons.lessonLines(p.canvasSize, p.color);
       await Promise.all(commands.map(cmd => sendCommand(cmd)));
-      return { content: [{ type: 'text', text: `✓ Bài học đường thẳng hoàn thành (${commands.length} nét vẽ)` }] };
+      return { content: [{ type: 'text', text: `✓ Lines lesson completed (${commands.length} strokes)` }] };
     });
 
   registerTool(server, 'art_tree_lesson_squares',
-    'Lesson: Hình vuông & Hình chữ nhật — Understanding right angles and proportions',
+    'Lesson: Squares & Rectangles — Understanding right angles and proportions',
     { canvasSize: z.number().int().min(16).max(64).default(32),
       color: hexColor.default('#1565c0') },
     async (p) => {
       const commands = lessons.lessonSquares(p.canvasSize, p.color);
       await Promise.all(commands.map(cmd => sendCommand(cmd)));
-      return { content: [{ type: 'text', text: `✓ Bài học hình vuông & chữ nhật hoàn thành (${commands.length} nét vẽ)` }] };
+      return { content: [{ type: 'text', text: `✓ Squares & Rectangles lesson completed (${commands.length} strokes)` }] };
     });
 
   registerTool(server, 'art_tree_lesson_circles',
-    'Lesson: Hình tròn — Learning curves and symmetry',
+    'Lesson: Circles — Learning curves and symmetry',
     { canvasSize: z.number().int().min(16).max(64).default(32),
       color: hexColor.default('#e91e63') },
     async (p) => {
       const commands = lessons.lessonCircles(p.canvasSize, p.color);
       await Promise.all(commands.map(cmd => sendCommand(cmd)));
-      return { content: [{ type: 'text', text: `✓ Bài học hình tròn hoàn thành (${commands.length} nét vẽ)` }] };
+      return { content: [{ type: 'text', text: `✓ Circles lesson completed (${commands.length} strokes)` }] };
     });
 
   registerTool(server, 'art_tree_lesson_ellipses',
-    'Lesson: Hình elip — Understanding oval shapes and proportions',
+    'Lesson: Ellipses — Understanding oval shapes and proportions',
     { canvasSize: z.number().int().min(16).max(64).default(32),
       color: hexColor.default('#9c27b0') },
     async (p) => {
       const commands = lessons.lessonEllipses(p.canvasSize, p.color);
       await Promise.all(commands.map(cmd => sendCommand(cmd)));
-      return { content: [{ type: 'text', text: `✓ Bài học hình elip hoàn thành (${commands.length} nét vẽ)` }] };
+      return { content: [{ type: 'text', text: `✓ Ellipses lesson completed (${commands.length} strokes)` }] };
     });
 
   registerTool(server, 'art_tree_lesson_triangles',
-    'Lesson: Hình tam giác — Three-point shapes and stability',
+    'Lesson: Triangles — Three-point shapes and stability',
     { canvasSize: z.number().int().min(16).max(64).default(32),
       color: hexColor.default('#ff5722') },
     async (p) => {
       const commands = lessons.lessonTriangles(p.canvasSize, p.color);
       await Promise.all(commands.map(cmd => sendCommand(cmd)));
-      return { content: [{ type: 'text', text: `✓ Bài học hình tam giác hoàn thành (${commands.length} nét vẽ)` }] };
+      return { content: [{ type: 'text', text: `✓ Triangles lesson completed (${commands.length} strokes)` }] };
     });
 
   registerTool(server, 'art_tree_lesson_polygons',
-    'Lesson: Đa giác — Multi-sided shapes',
+    'Lesson: Polygons — Multi-sided shapes',
     { canvasSize: z.number().int().min(16).max(64).default(32),
       color: hexColor.default('#607d8b') },
     async (p) => {
       const commands = lessons.lessonPolygons(p.canvasSize, p.color);
       await Promise.all(commands.map(cmd => sendCommand(cmd)));
-      return { content: [{ type: 'text', text: `✓ Bài học đa giác hoàn thành (${commands.length} nét vẽ)` }] };
+      return { content: [{ type: 'text', text: `✓ Polygons lesson completed (${commands.length} strokes)` }] };
     });
 
   registerTool(server, 'art_tree_lesson_composition',
-    'Lesson: Tổng hợp — Combining basic shapes to create simple objects (house, sun, tree)',
+    'Lesson: Composition — Combining basic shapes to create simple objects (house, sun, tree)',
     { canvasSize: z.number().int().min(16).max(64).default(32) },
     async (p) => {
       const commands = lessons.lessonComposition(p.canvasSize);
       await Promise.all(commands.map(cmd => sendCommand(cmd)));
-      return { content: [{ type: 'text', text: `✓ Bài học tổng hợp hoàn thành (${commands.length} nét vẽ)` }] };
+      return { content: [{ type: 'text', text: `✓ Composition lesson completed (${commands.length} strokes)` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_freehand',
+    'Lesson: Freehand Drawing — Practice freehand drawing without rulers',
+    { 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: `✓ Freehand drawing lesson completed (${commands.length} small segments)` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_proportions',
+    'Lesson: Proportions and Angles — Practice maintaining 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: `✓ Proportions and Angles lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_curves',
+    'Lesson: Curves — C-curves and S-curves',
+    { 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: `✓ Curves (C, S) lesson completed (${commands.length} strokes)` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_spiral',
+    'Lesson: Spiral — Drawing spiral curves',
+    { 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: `✓ Spiral lesson completed (${commands.length} strokes)` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_strokes',
+    'Lesson: Stroke Types — Long strokes, short strokes, thick and thin lines',
+    { 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: `✓ Strokes lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_parallel_intersecting',
+    'Lesson: Parallel & Intersecting Lines — Drawing parallel and intersecting lines',
+    { 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: `✓ Parallel & Intersecting Lines lesson completed` }] };
     });
 
   registerTool(server, 'art_tree_lesson_catalog',
@@ -172,7 +226,7 @@ function register(server) {
       const text = catalog.map(l =>
         `  • ${l.id}: ${l.name} — ${l.description}`
       ).join('\n');
-      return { content: [{ type: 'text', text: `📚 Danh sách bài học Art Tree:\n\n${text}` }] };
+      return { content: [{ type: 'text', text: `📚 Art Tree Lesson Catalog:\n\n${text}` }] };
     });
 }
 

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 (Narrow or bulge)
+ * 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 (Curved bending)
+ * 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
+};