@pixel-normal-edit/mcp 2.0.10 → 2.2.0

package/domains/art-tree/lessons/structure/complex-structure.js

@@ -0,0 +1,21 @@
+/**
+ * Auto-extracted from structure_lessons.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * Lesson: Complex Structure Analysis (e.g. A Bottle)
+ */
+function lessonComplexStructure(canvasSize = 32, color = '#9c27b0') {
+  const commands = [];
+  const cx = Math.floor(canvasSize / 2);
+  const cy = Math.floor(canvasSize / 2);
+  const totalHeight = Math.floor(canvasSize * 0.8);
+
+  // Draw bottle structure showing cross-sections and central axis
+  commands.push(...structureShapes.drawBottleAnatomy(cx, cy, totalHeight, color));
+
+  return commands;
+}
+
+module.exports = { lessonComplexStructure };

package/domains/art-tree/lessons/structure/x-yzaxes.js

@@ -0,0 +1,28 @@
+/**
+ * Auto-extracted from structure_lessons.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * Lesson: XYZ Axes (Vertical, Horizontal, Depth)
+ */
+function lessonXYZAxes(canvasSize = 32, color = '#2196f3') {
+  const commands = [];
+  const cx = Math.floor(canvasSize / 2);
+  const cy = Math.floor(canvasSize / 2);
+  const length = Math.floor(canvasSize * 0.4);
+
+  // Draw the axes
+  commands.push(...structureShapes.drawXYZAxes(cx, cy, length));
+  
+  // Draw a simple box aligned with these axes to show how objects follow them
+  const w = Math.floor(length * 0.5);
+  const h = Math.floor(length * 0.5);
+  const d = Math.floor(length * 0.5);
+  // Using a lighter color for the reference box
+  commands.push(...shapes3d.drawWireframeBox(cx + Math.floor(w/2), cy - Math.floor(h/2), w, h, d, '#e0e0e0'));
+
+  return commands;
+}
+
+module.exports = { lessonXYZAxes };

package/domains/art-tree/lessons/surfaces/chair-analysis.js

@@ -0,0 +1,17 @@
+/**
+ * Auto-extracted from surface_lessons.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * 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);
+}
+
+module.exports = { lessonChairAnalysis };

package/domains/art-tree/lessons/surfaces/cup-analysis.js

@@ -0,0 +1,18 @@
+/**
+ * Auto-extracted from surface_lessons.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * 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);
+}
+
+module.exports = { lessonCupAnalysis };

package/domains/art-tree/lessons/surfaces/edge-types.js

@@ -0,0 +1,40 @@
+/**
+ * Auto-extracted from surface_lessons.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * 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;
+}
+
+module.exports = { lessonEdgeTypes };

package/domains/art-tree/lessons/surfaces/surface-types.js

@@ -0,0 +1,42 @@
+/**
+ * Auto-extracted from surface_lessons.js
+ */
+const shapes = require('../../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;
+}
+
+module.exports = { lessonSurfaceTypes };

package/domains/art-tree/lessons/transforms/bend.js

@@ -0,0 +1,27 @@
+/**
+ * Auto-extracted from transform_lessons_1.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * 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 = { lessonBend };

package/domains/art-tree/{transform_lessons_2.js → lessons/transforms/combine.js}

@@ -1,53 +1,7 @@
-const shapes = require('./shapes');
-const transformShapes = require('./transform_shapes');
-const structureLessons = require('./structure_lessons');
-
-/**
- * Lesson: Rotate (Rotation)
- * 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 (Slice a form)
- * Sphere -> Truncated Sphere (exposing internal cross-section)
+ * Auto-extracted from transform_lessons_2.js
  */
-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 (Carve interior)
- * 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;
-}
+const shapes = require('../../shapes');
 
 /**
  * Lesson: Combine (Merge forms)
@@ -94,9 +48,4 @@ function lessonCombine(canvasSize = 32, color = '#607d8b') {
   return commands;
 }
 
-module.exports = {
-  lessonRotate,
-  lessonCut,
-  lessonHollow,
-  lessonCombine
-};
+module.exports = { lessonCombine };

package/domains/art-tree/lessons/transforms/cut.js

@@ -0,0 +1,25 @@
+/**
+ * Auto-extracted from transform_lessons_2.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * Lesson: Cut (Slice a form)
+ * 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;
+}
+
+module.exports = { lessonCut };

package/domains/art-tree/lessons/transforms/hollow.js

@@ -0,0 +1,24 @@
+/**
+ * Auto-extracted from transform_lessons_2.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * Lesson: Hollow (Carve interior)
+ * 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;
+}
+
+module.exports = { lessonHollow };

package/domains/art-tree/lessons/transforms/rotate.js

@@ -0,0 +1,16 @@
+/**
+ * Auto-extracted from transform_lessons_2.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * Lesson: Rotate (Rotation)
+ * 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);
+}
+
+module.exports = { lessonRotate };

package/domains/art-tree/lessons/transforms/squash.js

@@ -0,0 +1,31 @@
+/**
+ * Auto-extracted from transform_lessons_1.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * 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;
+}
+
+module.exports = { lessonSquash };

package/domains/art-tree/lessons/transforms/stretch.js

@@ -0,0 +1,31 @@
+/**
+ * Auto-extracted from transform_lessons_1.js
+ */
+const shapes = require('../../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;
+}
+
+module.exports = { lessonStretch };

package/domains/art-tree/lessons/transforms/taper-swell.js

@@ -0,0 +1,33 @@
+/**
+ * Auto-extracted from transform_lessons_1.js
+ */
+const shapes = require('../../shapes');
+
+/**
+ * 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;
+}
+
+module.exports = { lessonTaperSwell };

package/domains/art-tree/{vocab_lessons.js → lessons/vocab/vocab-house.js}

@@ -1,4 +1,7 @@
-const vocabShapes = require('./vocab_shapes');
+/**
+ * Auto-extracted from vocab_lessons.js
+ */
+const shapes = require('../../shapes');
 
 /**
  * Lesson: Visual Vocabulary - House Breakdown
@@ -15,18 +18,4 @@ function lessonVocabHouse(canvasSize = 64, step = 1) {
   return vocabShapes.drawHouseBreakdown(cx, cy, canvasSize, validStep);
 }
 
-function getVocabLessonCatalog() {
-  return [
-    { 
-      id: 'vocab_house', 
-      name: 'House Breakdown (5 Steps)', 
-      description: 'Break down a house: Masses -> Structural -> Functional -> Identity -> Materials. Supply step=1..5', 
-      fn: lessonVocabHouse 
-    }
-  ];
-}
-
-module.exports = {
-  lessonVocabHouse,
-  getVocabLessonCatalog
-};
+module.exports = { lessonVocabHouse };

package/domains/art-tree/lib/tool-register.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * tool-register.js — Art Tree: Tool Registration Helpers
+ *
+ * Provides helper functions to reduce boilerplate when registering
+ * Art Tree MCP tools. Common patterns are abstracted here.
+ */
+
+const { z } = require('zod');
+const { registerTool, sendCommand } = require('../../core/server');
+const { hexColor, canvasSize } = require('./validators');
+
+/**
+ * Register a lesson tool with standard pattern
+ * @param {McpServer} server - MCP server instance
+ * @param {string} name - Tool name
+ * @param {string} description - Tool description
+ * @param {Function} lessonFn - Function that returns array of commands
+ * @param {Object} [options] - Optional configuration
+ * @param {number} [options.canvasSizeMax=64] - Max canvas size
+ * @param {string} [options.defaultColor] - Default color (uses hexColor default if not provided)
+ */
+function registerLessonTool(server, name, description, lessonFn, options = {}) {
+  const { canvasSizeMax = 64, defaultColor } = options;
+  
+  const schema = {
+    canvasSize: canvasSize.max(canvasSizeMax),
+  };
+  
+  if (defaultColor) {
+    schema.color = hexColor.default(defaultColor);
+  }
+  
+  registerTool(server, name, description, schema, async (params) => {
+    const commands = lessonFn(params.canvasSize, params.color || defaultColor);
+    await Promise.all(commands.map(cmd => sendCommand(cmd)));
+    return { 
+      content: [{ 
+        type: 'text', 
+        text: `✓ ${description.split(' — ')[0]} completed (${commands.length} strokes)` 
+      }] 
+    };
+  });
+}
+
+/**
+ * Register a catalog tool that returns a list of available lessons
+ * @param {McpServer} server - MCP server instance
+ * @param {string} name - Tool name
+ * @param {string} description - Tool description
+ * @param {Function} getCatalogFn - Function that returns catalog array
+ * @param {string} catalogTitle - Title for the catalog output
+ */
+function registerCatalogTool(server, name, description, getCatalogFn, catalogTitle) {
+  registerTool(server, name, description, {}, () => {
+    const catalog = getCatalogFn();
+    const text = catalog.map(l =>
+      `  • ${l.id}: ${l.name} — ${l.description}`
+    ).join('\n');
+    return { content: [{ type: 'text', text: `📚 ${catalogTitle}:\n\n${text}` }] };
+  });
+}
+
+/**
+ * Register a tool that executes a specific lesson step
+ * @param {McpServer} server - MCP server instance
+ * @param {string} name - Tool name
+ * @param {string} description - Tool description
+ * @param {Function} lessonStepFn - Function that takes step number and returns commands
+ * @param {Object} [options] - Optional configuration
+ * @param {number} [options.minStep=1] - Minimum step number
+ * @param {number} [options.maxStep=10] - Maximum step number
+ * @param {number} [options.canvasSizeMax=64] - Max canvas size
+ * @param {string} [options.defaultColor] - Default color
+ */
+function registerStepTool(server, name, description, lessonStepFn, options = {}) {
+  const { minStep = 1, maxStep = 10, canvasSizeMax = 64, defaultColor } = options;
+  
+  const schema = {
+    canvasSize: canvasSize.max(canvasSizeMax),
+    step: z.number().int().min(minStep).max(maxStep).describe('Step number'),
+  };
+  
+  if (defaultColor) {
+    schema.color = hexColor.default(defaultColor);
+  }
+  
+  registerTool(server, name, description, schema, async (params) => {
+    const commands = lessonStepFn(params.canvasSize, params.step, params.color || defaultColor);
+    await Promise.all(commands.map(cmd => sendCommand(cmd)));
+    return { 
+      content: [{ 
+        type: 'text', 
+        text: `✓ ${description.split(' — ')[0]} - Step ${params.step} completed` 
+      }] 
+    };
+  });
+}
+
+module.exports = {
+  registerLessonTool,
+  registerCatalogTool,
+  registerStepTool,
+};

package/domains/art-tree/lib/validators.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * validators.js — Art Tree: Shared Zod Validators
+ *
+ * Common validation schemas used across all Art Tree tools.
+ * Centralizes repeated patterns to reduce code duplication.
+ */
+
+const { z } = require('zod');
+
+/**
+ * Hex color validator - ensures valid 6-character hex color codes
+ */
+const hexColor = z.string()
+  .regex(/^#[0-9a-fA-F]{6}$/)
+  .describe('Hex color e.g. #ff0000');
+
+/**
+ * Canvas size validator - ensures reasonable canvas dimensions
+ */
+const canvasSize = z.number()
+  .int()
+  .min(16)
+  .max(128)
+  .default(32)
+  .describe('Canvas dimension (16-128, default 32)');
+
+/**
+ * Coordinate validator - ensures integer coordinates
+ */
+const coordinate = z.number()
+  .int()
+  .describe('Integer coordinate');
+
+/**
+ * Positive integer validator - for sizes, counts, etc.
+ */
+const positiveInt = z.number()
+  .int()
+  .min(1)
+  .describe('Positive integer (min 1)');
+
+/**
+ * Radius validator - ensures positive radius
+ */
+const radius = z.number()
+  .int()
+  .min(1)
+  .describe('Radius (min 1)');
+
+/**
+ * Boolean with default false
+ */
+const booleanFalse = z.boolean()
+  .default(false)
+  .describe('Boolean flag (default false)');
+
+/**
+ * Common tool parameter schemas
+ */
+const schemas = {
+  hexColor,
+  canvasSize,
+  coordinate,
+  positiveInt,
+  radius,
+  booleanFalse,
+};
+
+module.exports = {
+  hexColor,
+  canvasSize,
+  coordinate,
+  positiveInt,
+  radius,
+  booleanFalse,
+  schemas,
+};

package/domains/art-tree/shapes/grid.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * shapes/grid.js — Art Tree: Grid Shape Primitives
+ *
+ * Grid-related shape drawing functions.
+ */
+
+const { drawLine } = require('./basic');
+
+/**
+ * Draw a grid of squares (useful for pixel art foundation lessons).
+ * @param {number} startX - Top-left X
+ * @param {number} startY - Top-left Y
+ * @param {number} cols - Number of columns
+ * @param {number} rows - Number of rows
+ * @param {number} cellSize - Size of each cell
+ * @param {string} color - Grid line color
+ * @returns {Array<Object>} Array of command payloads
+ */
+function drawGrid(startX, startY, cols, rows, cellSize, color) {
+  const commands = [];
+  // Horizontal lines
+  for (let r = 0; r <= rows; r++) {
+    const y = startY + r * cellSize;
+    commands.push(drawLine(startX, y, startX + cols * cellSize, y, color));
+  }
+  // Vertical lines
+  for (let c = 0; c <= cols; c++) {
+    const x = startX + c * cellSize;
+    commands.push(drawLine(x, startY, x, startY + rows * cellSize, color));
+  }
+  return commands;
+}
+
+module.exports = {
+  drawGrid,
+};