generate_color_variations

Instructions

Implementation Reference

• src/tools/generate-color-variations.ts:500-534 (handler)

  The ToolHandler implementation for 'generate_color_variations' tool, defining name, description, input schema, and the handler function.

  export const generateColorVariationsTool: ToolHandler = {
    name: 'generate_color_variations',
    description:
      'Generate tints, shades, and tones of a base color with mathematical precision. Tints add white, shades add black, and tones add gray.',
    parameters: {
      type: 'object',
      properties: {
        base_color: {
          type: 'string',
          description: 'Base color for generating variations',
        },
        variation_type: {
          type: 'string',
          enum: ['tints', 'shades', 'tones', 'all'],
          description: 'Type of variations to generate',
        },
        steps: {
          type: 'number',
          minimum: 3,
          maximum: 20,
          default: 10,
          description: 'Number of variation steps (3-20)',
        },
        intensity: {
          type: 'number',
          minimum: 0,
          maximum: 100,
          default: 50,
          description: 'Variation intensity percentage (0-100)',
        },
      },
      required: ['base_color', 'variation_type'],
    },
    handler: generateVariationsHandler,
  };

• src/tools/generate-color-variations.ts:99-117 (schema)

  Joi validation schema used internally for parameter validation in the handler.

  const generateVariationsSchema = Joi.object({
    base_color: Joi.string().required().messages({
      'string.empty': 'Base color is required',
    }),
    variation_type: Joi.string()
      .valid('tints', 'shades', 'tones', 'all')
      .required()
      .messages({
        'any.only': 'Variation type must be one of: tints, shades, tones, all',
      }),
    steps: Joi.number().integer().min(3).max(20).default(10).messages({
      'number.min': 'Minimum 3 steps required',
      'number.max': 'Maximum 20 steps allowed',
    }),
    intensity: Joi.number().min(0).max(100).default(50).messages({
      'number.min': 'Intensity must be between 0 and 100',
      'number.max': 'Intensity must be between 0 and 100',
    }),
  });

• src/tools/index.ts:135-135 (registration)

  Registration of the generate_color_variations tool into the central tool registry.

  toolRegistry.registerTool(generateColorVariationsTool);

• src/tools/generate-color-variations.ts:119-147 (helper)

  Helper function that generates tint variations by progressively increasing lightness from the base color.

  function generateTints(
    baseColor: UnifiedColor,
    steps: number,
    intensity: number
  ): UnifiedColor[] {
    const tints: UnifiedColor[] = [];
    const hsl = baseColor.hsl;
  
    // Generate tints by increasing lightness towards white
    for (let i = 0; i < steps; i++) {
      const factor = (i / (steps - 1)) * (intensity / 100);
      const newLightness = hsl.l + (100 - hsl.l) * factor;
  
      try {
        const tint = UnifiedColor.fromHsl(
          hsl.h,
          hsl.s,
          Math.min(100, Math.max(0, newLightness)),
          hsl.a
        );
        tints.push(tint);
      } catch {
        // Skip invalid colors
        continue;
      }
    }
  
    return tints;
  }

• src/tools/generate-color-variations.ts:149-177 (helper)

  Helper function that generates shade variations by progressively decreasing lightness from the base color.

  function generateShades(
    baseColor: UnifiedColor,
    steps: number,
    intensity: number
  ): UnifiedColor[] {
    const shades: UnifiedColor[] = [];
    const hsl = baseColor.hsl;
  
    // Generate shades by decreasing lightness towards black
    for (let i = 0; i < steps; i++) {
      const factor = (i / (steps - 1)) * (intensity / 100);
      const newLightness = hsl.l * (1 - factor);
  
      try {
        const shade = UnifiedColor.fromHsl(
          hsl.h,
          hsl.s,
          Math.min(100, Math.max(0, newLightness)),
          hsl.a
        );
        shades.push(shade);
      } catch {
        // Skip invalid colors
        continue;
      }
    }
  
    return shades;
  }