@pixel-normal-edit/mcp 2.0.5 → 2.0.7

package/domains/art-tree/cross_section_shapes.js

@@ -0,0 +1,84 @@
+const shapes = require('./shapes');
+const ellipseShapes = require('./ellipse_shapes');
+
+/**
+ * Draw a lofted 3D form by providing a central axis and cross-sections.
+ * @param {number} cx Center X
+ * @param {number} topY Top Y of the axis
+ * @param {number} bottomY Bottom Y of the axis
+ * @param {Array<{y: number, r: number}>} sections Slices sorted from top to bottom (or bottom to top)
+ * @param {string} color 
+ * @param {boolean} drawAxis Whether to draw the central vertical axis
+ */
+function drawLoftedForm(cx, topY, bottomY, sections, color, drawAxis = true) {
+  const commands = [];
+  
+  if (drawAxis) {
+    commands.push(shapes.drawLine(cx, topY - 5, cx, bottomY + 5, '#bdbdbd'));
+  }
+
+  // Sort sections by y to ensure we can connect them properly
+  const sorted = [...sections].sort((a, b) => a.y - b.y);
+
+  // Draw ellipses and connect edges
+  for (let i = 0; i < sorted.length; i++) {
+    const sec = sorted[i];
+    const ry = Math.max(2, Math.floor(sec.r * 0.3)); // perspective foreshortening
+    
+    // Draw cross-section ellipse
+    commands.push(shapes.drawEllipse(cx, sec.y, sec.r, ry, color, false));
+    
+    // Connect to next section's edges
+    if (i < sorted.length - 1) {
+      const nextSec = sorted[i + 1];
+      // Left contour
+      commands.push(shapes.drawLine(cx - sec.r, sec.y, cx - nextSec.r, nextSec.y, color));
+      // Right contour
+      commands.push(shapes.drawLine(cx + sec.r, sec.y, cx + nextSec.r, nextSec.y, color));
+    }
+  }
+
+  return commands;
+}
+
+/**
+ * Draw the structural volume of a head using cross sections
+ */
+function drawHeadStructure(cx, cy, height, color) {
+  const commands = [];
+  
+  const topY = cy - Math.floor(height / 2);
+  const bottomY = cy + Math.floor(height / 2);
+  
+  // 1. Cranium (large sphere at the top)
+  const craniumR = Math.floor(height * 0.35);
+  const craniumY = topY + craniumR;
+  commands.push(shapes.drawCircle(cx, craniumY, craniumR, color, false));
+  
+  // Cranium cross sections (horizontal and vertical)
+  commands.push(shapes.drawEllipse(cx, craniumY, craniumR, Math.floor(craniumR * 0.4), '#03a9f4', false));
+  commands.push(shapes.drawEllipse(cx, craniumY, Math.floor(craniumR * 0.3), craniumR, '#03a9f4', false));
+  
+  // 2. Face & Jaw (narrowing down)
+  const jawR = Math.floor(craniumR * 0.6);
+  const jawY = bottomY - Math.floor(jawR * 0.5);
+  
+  // Jaw cross section
+  commands.push(shapes.drawEllipse(cx, jawY, jawR, Math.floor(jawR * 0.3), '#e91e63', false));
+  
+  // Connect Cranium to Jaw (Cheekbones/Jawline)
+  // Left side
+  commands.push(shapes.drawLine(cx - craniumR, craniumY, cx - jawR, jawY, color));
+  // Right side
+  commands.push(shapes.drawLine(cx + craniumR, craniumY, cx + jawR, jawY, color));
+  
+  // Central facial axis (Center line of the face)
+  commands.push(shapes.drawLine(cx, topY, cx, bottomY, '#4caf50'));
+
+  return commands;
+}
+
+module.exports = {
+  drawLoftedForm,
+  drawHeadStructure
+};

package/domains/art-tree/cross_section_tools.js

@@ -0,0 +1,51 @@
+const { z } = require('zod');
+const { registerTool, sendCommand } = require('../../core/server');
+const csLessons = require('./cross_section_lessons');
+
+const hexColor = z.string().regex(/^#[0-9a-fA-F]{6}$/).describe('Hex color e.g. #ff0000');
+
+/**
+ * Register all cross-section tools on the MCP server.
+ * @param {McpServer} server
+ */
+function register(server) {
+  registerTool(server, 'art_tree_lesson_cs_bottle',
+    'Lesson: Cross-sections - Bottle Analysis (Base, body, shoulder, neck, mouth)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#2196f3') },
+    async (p) => {
+      const commands = csLessons.lessonBottleSections(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Bottle Cross-sections lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_cs_glass',
+    'Lesson: Cross-sections - Glass Analysis (Base, mid, mouth)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#9c27b0') },
+    async (p) => {
+      const commands = csLessons.lessonGlassSections(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Glass Cross-sections lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_cs_head',
+    'Lesson: Cross-sections - Head Analysis (Cranium, face, jaw)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#ff9800') },
+    async (p) => {
+      const commands = csLessons.lessonHeadSections(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Head Cross-sections lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_cs_catalog',
+    'Get the catalog of all available Cross-section lessons',
+    {},
+    () => {
+      const catalog = csLessons.getCrossSectionLessonCatalog();
+      const text = catalog.map(l =>
+        `  • ${l.id}: ${l.name} — ${l.description}`
+      ).join('\n');
+      return { content: [{ type: 'text', text: `📚 Cross-section Lessons:\n\n${text}` }] };
+    });
+}
+
+module.exports = { register };

package/domains/art-tree/curve_lessons.js

@@ -0,0 +1,138 @@
+const shapes = require('./shapes');
+const curveShapes = require('./curve_shapes');
+
+/**
+ * Lesson 1: Curve Types (C, S, Convex, Concave)
+ */
+function lessonCurveTypes(canvasSize = 32, color = '#2196f3') {
+  const margin = Math.floor(canvasSize * 0.1);
+  const commands = [];
+  
+  const w = Math.floor(canvasSize / 2) - margin * 2;
+  const h = Math.floor(canvasSize / 2) - margin * 2;
+
+  // C Curve (Top Left)
+  const cP0 = { x: margin + w, y: margin };
+  const cP1 = { x: margin - w, y: margin + Math.floor(h/2) }; // Pulls curve left
+  const cP2 = { x: margin + w, y: margin + h };
+  commands.push(...curveShapes.drawQuadraticCurve(cP0, cP1, cP2, color));
+
+  // S Curve (Top Right)
+  const sP0 = { x: canvasSize - margin, y: margin };
+  const sP1 = { x: canvasSize - margin - w*2, y: margin };
+  const sP2 = { x: canvasSize - margin + w, y: margin + h };
+  const sP3 = { x: canvasSize - margin - w, y: margin + h };
+  commands.push(...curveShapes.drawCubicCurve(sP0, sP1, sP2, sP3, '#e91e63'));
+
+  // Convex (Bottom Left, viewed from bottom)
+  const cvxP0 = { x: margin, y: canvasSize - margin };
+  const cvxP1 = { x: margin + Math.floor(w/2), y: canvasSize - margin - h };
+  const cvxP2 = { x: margin + w, y: canvasSize - margin };
+  commands.push(...curveShapes.drawQuadraticCurve(cvxP0, cvxP1, cvxP2, '#4caf50'));
+
+  // Concave (Bottom Right, viewed from bottom)
+  const cnvP0 = { x: canvasSize - margin - w, y: canvasSize - margin - Math.floor(h/2) };
+  const cnvP1 = { x: canvasSize - margin - Math.floor(w/2), y: canvasSize - margin + h };
+  const cnvP2 = { x: canvasSize - margin, y: canvasSize - margin - Math.floor(h/2) };
+  commands.push(...curveShapes.drawQuadraticCurve(cnvP0, cnvP1, cnvP2, '#ff9800'));
+
+  return commands;
+}
+
+/**
+ * Lesson 2: Curve Topology (Closed, Open, Symmetrical, Asymmetrical)
+ */
+function lessonCurveTopology(canvasSize = 32, color = '#9c27b0') {
+  const mid = Math.floor(canvasSize / 2);
+  const q = Math.floor(canvasSize / 4);
+  const commands = [];
+
+  // Closed Curve (Circle-like using Bezier for demonstration)
+  // Since we already have drawCircle, we just draw a circle to represent a closed curve
+  commands.push(shapes.drawCircle(q, q, Math.floor(q*0.8), color, false));
+  
+  // Open Curve (Quadratic)
+  commands.push(...curveShapes.drawQuadraticCurve(
+    { x: canvasSize - q*1.5, y: q },
+    { x: canvasSize - q*0.5, y: q - q/2 },
+    { x: canvasSize - q*0.5, y: q + q/2 },
+    '#3f51b5'
+  ));
+
+  // Symmetrical Curve (Parabola-like)
+  commands.push(...curveShapes.drawQuadraticCurve(
+    { x: q*0.5, y: canvasSize - q*0.5 },
+    { x: q, y: canvasSize - q*1.5 },
+    { x: q*1.5, y: canvasSize - q*0.5 },
+    '#00bcd4'
+  ));
+
+  // Asymmetrical Curve
+  commands.push(...curveShapes.drawQuadraticCurve(
+    { x: canvasSize - q*1.5, y: canvasSize - q*0.5 },
+    { x: canvasSize - q*0.2, y: canvasSize - q*1.8 }, // Pull point is skewed
+    { x: canvasSize - q*0.5, y: canvasSize - q*0.5 },
+    '#ff5722'
+  ));
+
+  return commands;
+}
+
+/**
+ * Lesson 3: Curve Properties (Start, Direction, Curvature, Inflection, Transition)
+ */
+function lessonCurveProperties(canvasSize = 32, color = '#607d8b') {
+  const margin = Math.floor(canvasSize * 0.1);
+  const commands = [];
+
+  // 1. Start point and Direction (Top Left Curve)
+  const p0 = { x: margin, y: margin * 2 };
+  const p1 = { x: margin + canvasSize*0.3, y: margin };
+  const p2 = { x: margin + canvasSize*0.3, y: margin + canvasSize*0.3 };
+  commands.push(...curveShapes.drawQuadraticCurve(p0, p1, p2, color));
+  commands.push(curveShapes.drawStartMarker(p0.x, p0.y, '#00ff00')); // Green dot at start
+  commands.push(...curveShapes.drawDirectionArrow(p0, p1, p2, null, '#ff0000')); // Red arrow
+
+  // 2. Curvature comparison (Bottom Left)
+  // Strong vs Weak curve with same endpoints
+  const bp0 = { x: margin, y: canvasSize - margin };
+  const bp2 = { x: margin + canvasSize*0.4, y: canvasSize - margin };
+  // Weak curve
+  commands.push(...curveShapes.drawQuadraticCurve(bp0, { x: margin + canvasSize*0.2, y: canvasSize - margin - canvasSize*0.1 }, bp2, '#8bc34a'));
+  // Strong curve
+  commands.push(...curveShapes.drawQuadraticCurve(bp0, { x: margin + canvasSize*0.2, y: canvasSize - margin - canvasSize*0.4 }, bp2, '#388e3c'));
+
+  // 3. Inflection point (Top Right S Curve)
+  const sP0 = { x: canvasSize - margin - canvasSize*0.3, y: margin };
+  const sP1 = { x: canvasSize - margin, y: margin };
+  const sP2 = { x: canvasSize - margin - canvasSize*0.4, y: margin + canvasSize*0.3 };
+  const sP3 = { x: canvasSize - margin, y: margin + canvasSize*0.3 };
+  commands.push(...curveShapes.drawCubicCurve(sP0, sP1, sP2, sP3, '#03a9f4'));
+  // Inflection point roughly at t=0.5
+  const inflection = curveShapes.cubicBezier(sP0, sP1, sP2, sP3, 0.5);
+  commands.push(curveShapes.drawInflectionMarker(inflection.x, inflection.y, '#ff9800'));
+
+  // 4. Transition (Bottom Right - line transitioning to curve)
+  const startLine = { x: canvasSize - margin - canvasSize*0.3, y: canvasSize - margin - canvasSize*0.2 };
+  const transPt = { x: canvasSize - margin - canvasSize*0.1, y: canvasSize - margin - canvasSize*0.2 };
+  commands.push(shapes.drawLine(startLine.x, startLine.y, transPt.x, transPt.y, '#9e9e9e'));
+  // Curve starting tangentially
+  commands.push(...curveShapes.drawQuadraticCurve(transPt, { x: canvasSize - margin, y: canvasSize - margin - canvasSize*0.2 }, { x: canvasSize - margin, y: canvasSize - margin }, '#795548'));
+
+  return commands;
+}
+
+function getCurveLessonCatalog() {
+  return [
+    { id: 'curve_types', name: 'Curve Types', description: 'C, S, Convex, and Concave curves', fn: lessonCurveTypes },
+    { id: 'curve_topology', name: 'Curve Topology', description: 'Closed, Open, Symmetrical, Asymmetrical curves', fn: lessonCurveTopology },
+    { id: 'curve_properties', name: 'Curve Properties', description: 'Start point, Direction, Curvature, Inflection, and Transitions', fn: lessonCurveProperties },
+  ];
+}
+
+module.exports = {
+  lessonCurveTypes,
+  lessonCurveTopology,
+  lessonCurveProperties,
+  getCurveLessonCatalog
+};

package/domains/art-tree/curve_shapes.js

@@ -0,0 +1,90 @@
+const shapes = require('./shapes');
+
+/**
+ * Draw a marker at the start of a curve
+ */
+function drawStartMarker(x, y, color = '#00ff00') {
+  return shapes.drawCircle(x, y, 2, color, true);
+}
+
+/**
+ * Draw an inflection point marker
+ */
+function drawInflectionMarker(x, y, color = '#ff0000') {
+  return shapes.drawCircle(x, y, 2, color, true);
+}
+
+/**
+ * Calculate quadratic bezier point
+ */
+function quadraticBezier(p0, p1, p2, t) {
+  const x = Math.round((1 - t) * (1 - t) * p0.x + 2 * (1 - t) * t * p1.x + t * t * p2.x);
+  const y = Math.round((1 - t) * (1 - t) * p0.y + 2 * (1 - t) * t * p1.y + t * t * p2.y);
+  return { x, y };
+}
+
+/**
+ * Draw a quadratic bezier curve as a polyline
+ */
+function drawQuadraticCurve(p0, p1, p2, color, segments = 20) {
+  const points = [];
+  for (let i = 0; i <= segments; i++) {
+    const t = i / segments;
+    points.push(quadraticBezier(p0, p1, p2, t));
+  }
+  return shapes.drawPolyline(points, color);
+}
+
+/**
+ * Calculate cubic bezier point
+ */
+function cubicBezier(p0, p1, p2, p3, t) {
+  const x = Math.round(Math.pow(1 - t, 3) * p0.x + 3 * Math.pow(1 - t, 2) * t * p1.x + 3 * (1 - t) * t * t * p2.x + t * t * t * p3.x);
+  const y = Math.round(Math.pow(1 - t, 3) * p0.y + 3 * Math.pow(1 - t, 2) * t * p1.y + 3 * (1 - t) * t * t * p2.y + t * t * t * p3.y);
+  return { x, y };
+}
+
+/**
+ * Draw a cubic bezier curve as a polyline
+ */
+function drawCubicCurve(p0, p1, p2, p3, color, segments = 30) {
+  const points = [];
+  for (let i = 0; i <= segments; i++) {
+    const t = i / segments;
+    points.push(cubicBezier(p0, p1, p2, p3, t));
+  }
+  return shapes.drawPolyline(points, color);
+}
+
+/**
+ * Draw a direction arrow roughly along the curve at t=0.5
+ */
+function drawDirectionArrow(p0, p1, p2, p3 = null, color = '#ff0000') {
+  const commands = [];
+  const t = 0.5;
+  const pt = p3 ? cubicBezier(p0, p1, p2, p3, t) : quadraticBezier(p0, p1, p2, t);
+  const ptNext = p3 ? cubicBezier(p0, p1, p2, p3, t + 0.1) : quadraticBezier(p0, p1, p2, t + 0.1);
+  
+  // Calculate angle
+  const angle = Math.atan2(ptNext.y - pt.y, ptNext.x - pt.x);
+  
+  // Draw arrow head
+  const arrowLen = 4;
+  const a1 = angle + Math.PI * 0.8;
+  const a2 = angle - Math.PI * 0.8;
+  
+  commands.push(shapes.drawLine(pt.x, pt.y, Math.round(pt.x + arrowLen * Math.cos(a1)), Math.round(pt.y + arrowLen * Math.sin(a1)), color));
+  commands.push(shapes.drawLine(pt.x, pt.y, Math.round(pt.x + arrowLen * Math.cos(a2)), Math.round(pt.y + arrowLen * Math.sin(a2)), color));
+  
+  return commands;
+}
+
+module.exports = {
+  drawStartMarker,
+  drawInflectionMarker,
+  quadraticBezier,
+  drawQuadraticCurve,
+  cubicBezier,
+  drawCubicCurve,
+  drawDirectionArrow
+};

package/domains/art-tree/curve_tools.js

@@ -0,0 +1,51 @@
+const { z } = require('zod');
+const { registerTool, sendCommand } = require('../../core/server');
+const curveLessons = require('./curve_lessons');
+
+const hexColor = z.string().regex(/^#[0-9a-fA-F]{6}$/).describe('Hex color e.g. #ff0000');
+
+/**
+ * Register all advanced curve tools on the MCP server.
+ * @param {McpServer} server
+ */
+function register(server) {
+  registerTool(server, 'art_tree_lesson_curve_types',
+    'Lesson: Advanced Curves - Types (C, S, Convex, Concave)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#2196f3') },
+    async (p) => {
+      const commands = curveLessons.lessonCurveTypes(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Curve Types lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_curve_topology',
+    'Lesson: Advanced Curves - Topology (Closed, Open, Symmetrical, Asymmetrical)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#9c27b0') },
+    async (p) => {
+      const commands = curveLessons.lessonCurveTopology(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Curve Topology lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_curve_properties',
+    'Lesson: Advanced Curves - Properties (Start, Direction, Curvature, Inflection, Transitions)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#607d8b') },
+    async (p) => {
+      const commands = curveLessons.lessonCurveProperties(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Curve Properties lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_curve_catalog',
+    'Get the catalog of all available Advanced Curve lessons',
+    {},
+    () => {
+      const catalog = curveLessons.getCurveLessonCatalog();
+      const text = catalog.map(l =>
+        `  • ${l.id}: ${l.name} — ${l.description}`
+      ).join('\n');
+      return { content: [{ type: 'text', text: `📚 Advanced Curve Lessons:\n\n${text}` }] };
+    });
+}
+
+module.exports = { register };

package/domains/art-tree/ellipse_lessons.js

@@ -0,0 +1,105 @@
+const shapes = require('./shapes');
+const ellipseShapes = require('./ellipse_shapes');
+
+/**
+ * Lesson: Ellipse Orientations (Horizontal, Vertical, Tilted)
+ */
+function lessonEllipseOrientations(canvasSize = 32, color = '#2196f3') {
+  const commands = [];
+  const midY = Math.floor(canvasSize / 2);
+  const qX = Math.floor(canvasSize / 4);
+  const rLong = Math.floor(canvasSize * 0.2);
+  const rShort = Math.floor(canvasSize * 0.1);
+
+  // Horizontal (Left)
+  commands.push(shapes.drawEllipse(qX, midY, rLong, rShort, color, false));
+  
+  // Vertical (Middle)
+  commands.push(shapes.drawEllipse(qX * 2, midY, rShort, rLong, '#e91e63', false));
+  
+  // Tilted (Right) - 45 degrees
+  commands.push(...ellipseShapes.drawRotatedEllipse(qX * 3, midY, rLong, rShort, Math.PI / 4, '#4caf50'));
+
+  return commands;
+}
+
+/**
+ * Lesson: Ellipse Proportions (Wide vs Narrow)
+ */
+function lessonEllipseProportions(canvasSize = 32, color = '#ff9800') {
+  const commands = [];
+  const midY = Math.floor(canvasSize / 2);
+  const qX = Math.floor(canvasSize / 4);
+  const rx = Math.floor(canvasSize * 0.2);
+
+  // Wide Ellipse (Closer to a circle)
+  commands.push(shapes.drawEllipse(qX, midY, rx, Math.floor(rx * 0.8), color, false));
+  
+  // Medium Ellipse
+  commands.push(shapes.drawEllipse(qX * 2, midY, rx, Math.floor(rx * 0.4), '#9c27b0', false));
+  
+  // Narrow Ellipse (Almost a line)
+  commands.push(shapes.drawEllipse(qX * 3, midY, rx, Math.floor(rx * 0.1), '#f44336', false));
+
+  return commands;
+}
+
+/**
+ * Lesson: Ellipse Anatomy (Symmetry, Major/Minor axes, Center)
+ */
+function lessonEllipseAnatomy(canvasSize = 32, color = '#00bcd4') {
+  const commands = [];
+  const cx = Math.floor(canvasSize / 2);
+  const cy = Math.floor(canvasSize / 2);
+  const rx = Math.floor(canvasSize * 0.35);
+  const ry = Math.floor(canvasSize * 0.2);
+  const angle = Math.PI / 6; // 30 degrees tilt to show axes clearly
+
+  // Draw ellipse
+  commands.push(...ellipseShapes.drawRotatedEllipse(cx, cy, rx, ry, angle, color));
+  
+  // Draw anatomy (axes and center)
+  commands.push(...ellipseShapes.drawEllipseAxes(cx, cy, rx, ry, angle));
+
+  return commands;
+}
+
+/**
+ * Lesson: Coaxial Ellipses (Multiple ellipses on the same axis)
+ */
+function lessonCoaxialEllipses(canvasSize = 32, color = '#795548') {
+  const commands = [];
+  const cx = Math.floor(canvasSize / 2);
+  const rx = Math.floor(canvasSize * 0.3);
+  
+  // Central axis line
+  commands.push(shapes.drawLine(cx, Math.floor(canvasSize * 0.1), cx, canvasSize - Math.floor(canvasSize * 0.1), '#bdbdbd'));
+  
+  // Top ellipse (narrower, viewed from steeper angle)
+  commands.push(shapes.drawEllipse(cx, Math.floor(canvasSize * 0.2), rx, Math.floor(rx * 0.2), color, false));
+  
+  // Middle ellipse
+  commands.push(shapes.drawEllipse(cx, Math.floor(canvasSize * 0.5), rx, Math.floor(rx * 0.3), color, false));
+  
+  // Bottom ellipse (wider, viewed from less steep angle)
+  commands.push(shapes.drawEllipse(cx, canvasSize - Math.floor(canvasSize * 0.2), rx, Math.floor(rx * 0.4), color, false));
+
+  return commands;
+}
+
+function getEllipseLessonCatalog() {
+  return [
+    { id: 'ellipse_orientations', name: 'Ellipse Orientations', description: 'Horizontal, Vertical, and Tilted ellipses', fn: lessonEllipseOrientations },
+    { id: 'ellipse_proportions', name: 'Ellipse Proportions', description: 'Wide vs Narrow ellipses', fn: lessonEllipseProportions },
+    { id: 'ellipse_anatomy', name: 'Ellipse Anatomy', description: 'Symmetry, Major/Minor axes, and Center', fn: lessonEllipseAnatomy },
+    { id: 'ellipse_coaxial', name: 'Coaxial Ellipses', description: 'Multiple ellipses sharing the same axis', fn: lessonCoaxialEllipses },
+  ];
+}
+
+module.exports = {
+  lessonEllipseOrientations,
+  lessonEllipseProportions,
+  lessonEllipseAnatomy,
+  lessonCoaxialEllipses,
+  getEllipseLessonCatalog
+};

package/domains/art-tree/ellipse_shapes.js

@@ -0,0 +1,63 @@
+const shapes = require('./shapes');
+
+/**
+ * Draw a rotated ellipse using a polygon approximation
+ * @param {number} cx Center X
+ * @param {number} cy Center Y
+ * @param {number} rx X radius (major axis if rx > ry)
+ * @param {number} ry Y radius
+ * @param {number} angle Rotation angle in radians
+ * @param {string} color Hex color
+ * @param {number} segments Number of polygon segments
+ */
+function drawRotatedEllipse(cx, cy, rx, ry, angle, color, segments = 36) {
+  const points = [];
+  const cosA = Math.cos(angle);
+  const sinA = Math.sin(angle);
+  
+  for (let i = 0; i <= segments; i++) {
+    const t = (i / segments) * 2 * Math.PI;
+    const px = rx * Math.cos(t);
+    const py = ry * Math.sin(t);
+    
+    const x = Math.round(cx + px * cosA - py * sinA);
+    const y = Math.round(cy + px * sinA + py * cosA);
+    points.push({ x, y });
+  }
+  
+  return shapes.drawPolyline(points, color);
+}
+
+/**
+ * Draw major and minor axes for an ellipse
+ */
+function drawEllipseAxes(cx, cy, rx, ry, angle = 0) {
+  const commands = [];
+  const cosA = Math.cos(angle);
+  const sinA = Math.sin(angle);
+  
+  // Major/Minor Axis calculation based on rotation
+  const x1 = Math.round(cx - rx * cosA);
+  const y1 = Math.round(cy - rx * sinA);
+  const x2 = Math.round(cx + rx * cosA);
+  const y2 = Math.round(cy + rx * sinA);
+  
+  const y3_x = Math.round(cx + ry * sinA);
+  const y3_y = Math.round(cy - ry * cosA);
+  const y4_x = Math.round(cx - ry * sinA);
+  const y4_y = Math.round(cy + ry * cosA);
+
+  // Red for Major, Blue for Minor
+  commands.push(shapes.drawLine(x1, y1, x2, y2, '#ff0000'));
+  commands.push(shapes.drawLine(y3_x, y3_y, y4_x, y4_y, '#2196f3'));
+  
+  // Center dot
+  commands.push(shapes.drawCircle(cx, cy, 1, '#000000', true));
+  
+  return commands;
+}
+
+module.exports = {
+  drawRotatedEllipse,
+  drawEllipseAxes
+};

package/domains/art-tree/ellipse_tools.js

@@ -0,0 +1,60 @@
+const { z } = require('zod');
+const { registerTool, sendCommand } = require('../../core/server');
+const ellipseLessons = require('./ellipse_lessons');
+
+const hexColor = z.string().regex(/^#[0-9a-fA-F]{6}$/).describe('Hex color e.g. #ff0000');
+
+/**
+ * Register all ellipse tools on the MCP server.
+ * @param {McpServer} server
+ */
+function register(server) {
+  registerTool(server, 'art_tree_lesson_ellipse_orientations',
+    'Lesson: Ellipses - Orientations (Horizontal, Vertical, Tilted)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#2196f3') },
+    async (p) => {
+      const commands = ellipseLessons.lessonEllipseOrientations(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Ellipse Orientations lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_ellipse_proportions',
+    'Lesson: Ellipses - Proportions (Wide vs Narrow)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#ff9800') },
+    async (p) => {
+      const commands = ellipseLessons.lessonEllipseProportions(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Ellipse Proportions lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_ellipse_anatomy',
+    'Lesson: Ellipses - Anatomy (Symmetry, Axes, Center)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#00bcd4') },
+    async (p) => {
+      const commands = ellipseLessons.lessonEllipseAnatomy(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Ellipse Anatomy lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_coaxial_ellipses',
+    'Lesson: Ellipses - Coaxial (Multiple ellipses on the same axis)',
+    { canvasSize: z.number().int().min(16).max(64).default(32), color: hexColor.default('#795548') },
+    async (p) => {
+      const commands = ellipseLessons.lessonCoaxialEllipses(p.canvasSize, p.color);
+      await Promise.all(commands.map(cmd => sendCommand(cmd)));
+      return { content: [{ type: 'text', text: `✓ Coaxial Ellipses lesson completed` }] };
+    });
+
+  registerTool(server, 'art_tree_lesson_ellipse_catalog',
+    'Get the catalog of all available Ellipse lessons',
+    {},
+    () => {
+      const catalog = ellipseLessons.getEllipseLessonCatalog();
+      const text = catalog.map(l =>
+        `  • ${l.id}: ${l.name} — ${l.description}`
+      ).join('\n');
+      return { content: [{ type: 'text', text: `📚 Ellipse Lessons:\n\n${text}` }] };
+    });
+}
+
+module.exports = { register };