export_json

Instructions

Implementation Reference

• src/tools/export-json.ts:99-184 (handler)

  Core handler function that validates input parameters, parses colors, generates JSON in specified format (simple, detailed, api, design_tokens), creates additional CSS/SCSS exports, and returns structured success/error response.

  async function exportJson(
    params: ExportJsonParams
  ): Promise<ToolResponse | ErrorResponse> {
    const startTime = Date.now();
  
    try {
      // Validate parameters
      const { error, value: validatedParams } = exportJsonSchema.validate(params);
      if (error) {
        return createErrorResponse(
          'export_json',
          'INVALID_PARAMETERS',
          `Invalid parameters: ${error.details.map(d => d.message).join(', ')}`,
          Date.now() - startTime
        );
      }
  
      // Parse colors
      const colors: UnifiedColor[] = [];
      for (const colorStr of validatedParams.colors) {
        try {
          const color = new UnifiedColor(colorStr);
          colors.push(color);
        } catch {
          return createErrorResponse(
            'export_json',
            'INVALID_COLOR',
            `Invalid color format: ${colorStr}`,
            Date.now() - startTime,
            {
              details: { provided: colorStr },
              suggestions: [
                'Use hex format like #FF0000',
                'Use RGB format like rgb(255, 0, 0)',
                'Use HSL format like hsl(0, 100%, 50%)',
              ],
            }
          );
        }
      }
  
      // Generate JSON based on format
      const jsonData = generateJSON(colors, validatedParams);
      const jsonString = validatedParams.pretty_print
        ? JSON.stringify(jsonData, null, 2)
        : JSON.stringify(jsonData);
  
      // Generate additional export formats
      const exportFormats = {
        json: jsonData,
        css: generateCSSFromJSON(jsonData),
        scss: generateSCSSFromJSON(jsonData),
      };
  
      const executionTime = Date.now() - startTime;
  
      return createSuccessResponse(
        'export_json',
        {
          json_output: jsonString,
          format: validatedParams.format,
          color_count: colors.length,
          includes_metadata: validatedParams.include_metadata,
          includes_accessibility: validatedParams.include_accessibility,
          includes_variations: validatedParams.include_variations,
          file_size: jsonString.length,
        },
        executionTime,
        {
          recommendations: [
            'Use the detailed format for comprehensive color information',
            'Consider the API format for web service integration',
            'Use design tokens format for design system integration',
          ],
          exportFormats,
        }
      );
    } catch (error) {
      return createErrorResponse(
        'export_json',
        'PROCESSING_ERROR',
        error instanceof Error ? error.message : 'Unknown error occurred',
        Date.now() - startTime
      );
    }
  }

• src/tools/export-json.ts:11-49 (schema)

  Joi schema defining the input parameters for the tool, including required colors array, optional format (simple/detailed/api/design_tokens), metadata/accessibility/variations flags, semantic names, group name, version, and pretty_print option.

  const exportJsonSchema = Joi.object({
    colors: Joi.array()
      .items(Joi.string())
      .min(1)
      .max(100)
      .required()
      .description('Array of colors to export'),
  
    format: Joi.string()
      .valid('simple', 'detailed', 'api', 'design_tokens')
      .default('detailed')
      .description('JSON format structure'),
  
    include_metadata: Joi.boolean()
      .default(true)
      .description('Include color analysis metadata'),
  
    include_accessibility: Joi.boolean()
      .default(true)
      .description('Include accessibility information'),
  
    include_variations: Joi.boolean()
      .default(false)
      .description('Include color variations (tints, shades)'),
  
    semantic_names: Joi.array()
      .items(Joi.string())
      .description('Optional semantic names for colors'),
  
    group_name: Joi.string().description('Name for the color group/palette'),
  
    version: Joi.string()
      .default('1.0.0')
      .description('Version number for the palette'),
  
    pretty_print: Joi.boolean()
      .default(true)
      .description('Format JSON with indentation'),
  });

• src/tools/export-json.ts:534-540 (registration)

  ToolHandler definition and export for 'export_json', including name, description, parameters from schema, and handler that delegates to the main exportJson function.

  export const exportJsonTool: ToolHandler = {
    name: 'export_json',
    description:
      'Generate JSON format for programmatic use and API integration with multiple structure options',
    parameters: exportJsonSchema.describe(),
    handler: async (params: unknown) => exportJson(params as ExportJsonParams),
  };

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

  Registration of export format tools including exportJsonTool into the central ToolRegistry singleton.

  // Register export format tools
  toolRegistry.registerTool(exportCssTool);
  toolRegistry.registerTool(exportScssTool);
  toolRegistry.registerTool(exportTailwindTool);
  toolRegistry.registerTool(exportJsonTool);

• src/tools/export-json.ts:189-211 (helper)

  Helper function that dispatches to specific JSON generators based on the requested format: simple, detailed, api, or design_tokens.

  function generateJSON(
    colors: UnifiedColor[],
    params: ExportJsonParams
  ): Record<string, unknown> | DetailedJsonResult {
    const { format } = params;
  
    switch (format) {
      case 'simple':
        return generateSimpleJSON(colors, params.semantic_names);
  
      case 'detailed':
        return generateDetailedJSON(colors, params);
  
      case 'api':
        return generateAPIJSON(colors, params);
  
      case 'design_tokens':
        return generateDesignTokensJSON(colors, params);
  
      default:
        return generateDetailedJSON(colors, params);
    }
  }