@forgespace/branding-mcp 0.7.0 → 0.7.1

package/src/lib/branding-core/ai/claude-interpreter.ts

@@ -1,76 +0,0 @@
-import type { BrandIdentity } from '../../types.js';
-import type { BrandIntent, InterpreterOptions } from './types.js';
-import { buildRefinementPrompt, buildGenerationPrompt } from './prompts.js';
-import { logger } from '../../logger.js';
-
-async function callClaude(prompt: string, options: Required<InterpreterOptions>): Promise<string> {
-  const response = await fetch('https://api.anthropic.com/v1/messages', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'x-api-key': options.anthropicApiKey,
-      'anthropic-version': '2023-06-01',
-    },
-    body: JSON.stringify({
-      model: options.model,
-      max_tokens: options.maxTokens,
-      messages: [{ role: 'user', content: prompt }],
-    }),
-  });
-
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(`Anthropic API error ${response.status}: ${body}`);
-  }
-
-  const data = (await response.json()) as {
-    content: Array<{ type: string; text: string }>;
-  };
-  const textBlock = data.content.find((b) => b.type === 'text');
-  if (!textBlock) throw new Error('No text content in Anthropic response');
-  return textBlock.text;
-}
-
-function parseIntentJson(raw: string): BrandIntent {
-  const jsonMatch = raw.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) throw new Error('No JSON object found in AI response');
-  return JSON.parse(jsonMatch[0]) as BrandIntent;
-}
-
-export async function interpretWithClaude(
-  feedback: string,
-  element: 'colors' | 'typography' | 'spacing',
-  currentBrand: BrandIdentity,
-  options: InterpreterOptions
-): Promise<BrandIntent> {
-  const opts: Required<InterpreterOptions> = {
-    anthropicApiKey: options.anthropicApiKey ?? '',
-    model: options.model ?? 'claude-sonnet-4-20250514',
-    maxTokens: options.maxTokens ?? 512,
-  };
-
-  const prompt = buildRefinementPrompt(feedback, element, currentBrand);
-  logger.info({ element, model: opts.model }, 'Interpreting feedback with Claude');
-
-  const raw = await callClaude(prompt, opts);
-  return parseIntentJson(raw);
-}
-
-export async function suggestBrandWithClaude(
-  brandName: string,
-  industry: string,
-  description: string,
-  options: InterpreterOptions
-): Promise<BrandIntent> {
-  const opts: Required<InterpreterOptions> = {
-    anthropicApiKey: options.anthropicApiKey ?? '',
-    model: options.model ?? 'claude-sonnet-4-20250514',
-    maxTokens: options.maxTokens ?? 512,
-  };
-
-  const prompt = buildGenerationPrompt(brandName, industry, description);
-  logger.info({ brandName, model: opts.model }, 'Generating brand suggestions with Claude');
-
-  const raw = await callClaude(prompt, opts);
-  return parseIntentJson(raw);
-}

package/src/lib/branding-core/ai/intent-applier.ts

@@ -1,59 +0,0 @@
-import type { BrandIdentity } from '../../types.js';
-import type { BrandIntent } from './types.js';
-import { generateColorPalette, hexToHsl, hslToHex } from '../generators/color-palette.js';
-import { generateTypographySystem } from '../generators/typography-system.js';
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
-function applyColorShifts(
-  baseHex: string,
-  hueShift: number,
-  saturationShift: number,
-  lightnessShift: number
-): string {
-  const hsl = hexToHsl(baseHex);
-  return hslToHex(
-    (hsl.h + hueShift + 360) % 360,
-    clamp(hsl.s + saturationShift, 0, 100),
-    clamp(hsl.l + lightnessShift, 5, 95)
-  );
-}
-
-export function applyIntent(brand: BrandIdentity, intent: BrandIntent): BrandIdentity {
-  const updated = { ...brand };
-
-  if (intent.color) {
-    const { baseColor, harmony, theme, hueShift, saturationShift, lightnessShift } = intent.color;
-
-    let effectiveBase = baseColor ?? brand.colors.primary.hex;
-
-    if (hueShift || saturationShift || lightnessShift) {
-      effectiveBase = applyColorShifts(
-        effectiveBase,
-        hueShift ?? 0,
-        saturationShift ?? 0,
-        lightnessShift ?? 0
-      );
-    }
-
-    updated.colors = generateColorPalette(effectiveBase, harmony ?? 'complementary', theme);
-  }
-
-  if (intent.typography) {
-    const { headingCategory, bodyCategory, scaleRatio, baseSize } = intent.typography;
-    updated.typography = generateTypographySystem(
-      (headingCategory ?? brand.typography.headingFont.includes('serif')) ? 'serif' : 'sans-serif',
-      bodyCategory ?? 'sans-serif',
-      scaleRatio,
-      baseSize ?? brand.typography.baseSize
-    );
-  }
-
-  if (intent.style) {
-    updated.style = intent.style;
-  }
-
-  return updated;
-}

package/src/lib/branding-core/ai/keyword-interpreter.ts

@@ -1,95 +0,0 @@
-import type { BrandIdentity } from '../../types.js';
-import type { BrandIntent, ColorIntent, TypographyIntent } from './types.js';
-
-const COLOR_KEYWORDS: Record<string, ColorIntent> = {
-  warm: { harmony: 'analogous', hueShift: 15 },
-  cool: { harmony: 'analogous', hueShift: -15 },
-  subtle: { harmony: 'analogous', saturationShift: -15 },
-  vibrant: { harmony: 'triadic', saturationShift: 15 },
-  bold: { harmony: 'complementary', saturationShift: 10 },
-  muted: { harmony: 'monochromatic', saturationShift: -20 },
-  dark: { theme: 'dark', lightnessShift: -15 },
-  light: { theme: 'light', lightnessShift: 15 },
-  monochromatic: { harmony: 'monochromatic' },
-  complementary: { harmony: 'complementary' },
-  analogous: { harmony: 'analogous' },
-  triadic: { harmony: 'triadic' },
-  premium: { harmony: 'analogous', saturationShift: -10, lightnessShift: -10 },
-  playful: { harmony: 'triadic', saturationShift: 15, lightnessShift: 5 },
-  corporate: { harmony: 'complementary', saturationShift: -10 },
-  organic: { harmony: 'analogous', hueShift: 30 },
-  elegant: { harmony: 'monochromatic', saturationShift: -15, lightnessShift: -5 },
-};
-
-const TYPOGRAPHY_KEYWORDS: Record<string, TypographyIntent> = {
-  serif: { headingCategory: 'serif' },
-  'sans-serif': { headingCategory: 'sans-serif' },
-  mono: { bodyCategory: 'monospace' },
-  monospace: { bodyCategory: 'monospace' },
-  display: { headingCategory: 'display' },
-  handwritten: { headingCategory: 'handwriting' },
-  compact: { scaleRatio: 'minor-second' },
-  tight: { scaleRatio: 'major-second' },
-  spacious: { scaleRatio: 'perfect-fourth' },
-  dramatic: { scaleRatio: 'golden-ratio' },
-  larger: { baseSize: 18 },
-  smaller: { baseSize: 14 },
-  editorial: { headingCategory: 'serif', scaleRatio: 'perfect-fourth' },
-  technical: { bodyCategory: 'monospace', headingCategory: 'sans-serif' },
-  modern: { headingCategory: 'sans-serif', bodyCategory: 'sans-serif' },
-  classic: { headingCategory: 'serif', bodyCategory: 'serif' },
-};
-
-function mergeColorIntents(intents: ColorIntent[]): ColorIntent {
-  const merged: ColorIntent = {};
-  for (const intent of intents) {
-    if (intent.harmony) merged.harmony = intent.harmony;
-    if (intent.theme) merged.theme = intent.theme;
-    if (intent.baseColor) merged.baseColor = intent.baseColor;
-    merged.saturationShift = (merged.saturationShift ?? 0) + (intent.saturationShift ?? 0);
-    merged.lightnessShift = (merged.lightnessShift ?? 0) + (intent.lightnessShift ?? 0);
-    merged.hueShift = (merged.hueShift ?? 0) + (intent.hueShift ?? 0);
-  }
-  return merged;
-}
-
-export function interpretWithKeywords(
-  feedback: string,
-  element: 'colors' | 'typography' | 'spacing',
-  _currentBrand?: BrandIdentity
-): BrandIntent {
-  const lower = feedback.toLowerCase();
-
-  if (element === 'colors') {
-    const matched: ColorIntent[] = [];
-    for (const [keyword, intent] of Object.entries(COLOR_KEYWORDS)) {
-      if (lower.includes(keyword)) {
-        matched.push(intent);
-      }
-    }
-    return {
-      color: matched.length > 0 ? mergeColorIntents(matched) : { harmony: 'complementary' },
-      reasoning: `Keyword match: ${matched.length > 0 ? 'matched color keywords' : 'default fallback'}`,
-    };
-  }
-
-  if (element === 'typography') {
-    const matched: TypographyIntent[] = [];
-    for (const [keyword, intent] of Object.entries(TYPOGRAPHY_KEYWORDS)) {
-      if (lower.includes(keyword)) {
-        matched.push(intent);
-      }
-    }
-    const merged: TypographyIntent = {};
-    for (const intent of matched) {
-      Object.assign(merged, intent);
-    }
-    return {
-      typography:
-        Object.keys(merged).length > 0 ? merged : { headingCategory: 'sans-serif' as const },
-      reasoning: `Keyword match: ${matched.length > 0 ? 'matched typography keywords' : 'default fallback'}`,
-    };
-  }
-
-  return { reasoning: 'No actionable keywords found for spacing refinement' };
-}

package/src/lib/branding-core/ai/prompts.ts

@@ -1,93 +0,0 @@
-import type { BrandIdentity } from '../../types.js';
-
-export function buildRefinementPrompt(
-  feedback: string,
-  element: 'colors' | 'typography' | 'spacing',
-  currentBrand: BrandIdentity
-): string {
-  const brandContext = [
-    `Brand: ${currentBrand.name}`,
-    `Industry: ${currentBrand.industry}`,
-    `Style: ${currentBrand.style}`,
-    `Current primary color: ${currentBrand.colors.primary.hex}`,
-    `Current heading font: ${currentBrand.typography.headingFont}`,
-    `Current body font: ${currentBrand.typography.bodyFont}`,
-  ].join('\n');
-
-  const colorSchema = `{
-  "color": {
-    "baseColor": "#hex (optional, keep current if not changing)",
-    "harmony": "complementary|analogous|triadic|split-complementary|tetradic|monochromatic",
-    "theme": "light|dark|both",
-    "saturationShift": number (-30 to 30),
-    "lightnessShift": number (-30 to 30),
-    "hueShift": number (-180 to 180)
-  },
-  "reasoning": "1-2 sentences explaining the design decision"
-}`;
-
-  const typographySchema = `{
-  "typography": {
-    "headingCategory": "serif|sans-serif|monospace|display|handwriting",
-    "bodyCategory": "serif|sans-serif|monospace|display|handwriting",
-    "scaleRatio": "minor-second|major-second|minor-third|major-third|perfect-fourth|augmented-fourth|perfect-fifth|golden-ratio",
-    "baseSize": number (12-24)
-  },
-  "reasoning": "1-2 sentences explaining the design decision"
-}`;
-
-  const schema = element === 'colors' ? colorSchema : typographySchema;
-
-  return [
-    'You are a brand identity expert. Interpret the user feedback and output a JSON object with specific design parameters.',
-    '',
-    'Current brand context:',
-    brandContext,
-    '',
-    `User wants to refine: ${element}`,
-    `User feedback: "${feedback}"`,
-    '',
-    'Respond with ONLY valid JSON matching this schema:',
-    schema,
-    '',
-    'Design principles:',
-    '- Warm colors: shift hue toward red/orange (positive hueShift), use analogous harmony',
-    '- Cool colors: shift hue toward blue/green (negative hueShift)',
-    '- Premium feel: lower saturation, slightly darker, analogous or monochromatic',
-    '- Playful: higher saturation, lighter, triadic harmony',
-    '- Corporate: moderate saturation, complementary, clean sans-serif',
-    '- Editorial: serif headings, perfect-fourth or larger scale ratio',
-    '- Technical: monospace body, sans-serif headings, compact scale',
-    '- WCAG: ensure contrast ratios remain accessible (>= 4.5:1 on white)',
-  ].join('\n');
-}
-
-export function buildGenerationPrompt(
-  brandName: string,
-  industry: string,
-  description: string
-): string {
-  return [
-    'You are a brand identity expert. Based on the brand description, suggest specific design parameters.',
-    '',
-    `Brand name: ${brandName}`,
-    `Industry: ${industry}`,
-    `Description: "${description}"`,
-    '',
-    'Respond with ONLY valid JSON:',
-    '{',
-    '  "style": "minimal|bold|elegant|playful|corporate|tech|organic|retro",',
-    '  "color": {',
-    '    "baseColor": "#hex",',
-    '    "harmony": "complementary|analogous|triadic|split-complementary|tetradic|monochromatic",',
-    '    "theme": "light|dark|both"',
-    '  },',
-    '  "typography": {',
-    '    "headingCategory": "serif|sans-serif|monospace|display|handwriting",',
-    '    "bodyCategory": "serif|sans-serif|monospace|display|handwriting",',
-    '    "scaleRatio": "minor-second|major-second|minor-third|major-third|perfect-fourth|augmented-fourth|perfect-fifth|golden-ratio"',
-    '  },',
-    '  "reasoning": "2-3 sentences explaining why these choices fit the brand"',
-    '}',
-  ].join('\n');
-}

package/src/lib/branding-core/ai/types.ts

@@ -1,36 +0,0 @@
-import type {
-  BrandStyle,
-  ColorHarmony,
-  ColorTheme,
-  FontCategory,
-  TypeScaleRatio,
-} from '../../types.js';
-
-export interface ColorIntent {
-  baseColor?: string;
-  harmony?: ColorHarmony;
-  theme?: ColorTheme;
-  saturationShift?: number;
-  lightnessShift?: number;
-  hueShift?: number;
-}
-
-export interface TypographyIntent {
-  headingCategory?: FontCategory;
-  bodyCategory?: FontCategory;
-  scaleRatio?: TypeScaleRatio;
-  baseSize?: number;
-}
-
-export interface BrandIntent {
-  color?: ColorIntent;
-  typography?: TypographyIntent;
-  style?: BrandStyle;
-  reasoning?: string;
-}
-
-export interface InterpreterOptions {
-  anthropicApiKey?: string;
-  model?: string;
-  maxTokens?: number;
-}

package/src/lib/branding-core/documents/html-generator.ts

@@ -1,32 +0,0 @@
-import type { BrandIdentity } from '../../types.js';
-
-export function generateBrandHtml(brand: BrandIdentity): string {
-  const { colors, typography, spacing } = brand;
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>${brand.name} Brand Book</title>
-</head>
-<body>
-  <h1>${brand.name}</h1>
-  ${brand.tagline ? `<p>${brand.tagline}</p>` : ''}
-  <section>
-    <h2>Colors</h2>
-    <p>Primary: ${colors.primary.hex}</p>
-    <p>Secondary: ${colors.secondary.hex}</p>
-    <p>Accent: ${colors.accent.hex}</p>
-  </section>
-  <section>
-    <h2>Typography</h2>
-    <p>Heading: ${typography.headingFont}</p>
-    <p>Body: ${typography.bodyFont}</p>
-    <p>Scale: ${typography.scaleRatio}</p>
-  </section>
-  <section>
-    <h2>Spacing</h2>
-    <p>Base unit: ${spacing.unit}px</p>
-  </section>
-</body>
-</html>`;
-}

package/src/lib/branding-core/documents/pdf-generator.ts

@@ -1,21 +0,0 @@
-import type { BrandIdentity } from '../../types.js';
-
-export function generateBrandPdfContent(brand: BrandIdentity): string {
-  return [
-    `${brand.name} Brand Guidelines`,
-    brand.tagline ?? '',
-    '',
-    'Colors',
-    `  Primary: ${brand.colors.primary.hex}`,
-    `  Secondary: ${brand.colors.secondary.hex}`,
-    `  Accent: ${brand.colors.accent.hex}`,
-    '',
-    'Typography',
-    `  Heading: ${brand.typography.headingFont}`,
-    `  Body: ${brand.typography.bodyFont}`,
-    `  Base size: ${brand.typography.baseSize}px`,
-    '',
-    'Spacing',
-    `  Base unit: ${brand.spacing.unit}px`,
-  ].join('\n');
-}

package/src/lib/branding-core/exporters/css-variables.ts

@@ -1,71 +0,0 @@
-import type { BrandIdentity } from '../../types.js';
-
-export function exportCssVariables(brand: BrandIdentity): string {
-  const { colors, typography, spacing } = brand;
-  const lines: string[] = [':root {'];
-
-  lines.push(`  --color-primary: ${colors.primary.hex};`);
-  lines.push(`  --color-secondary: ${colors.secondary.hex};`);
-  lines.push(`  --color-accent: ${colors.accent.hex};`);
-  for (const n of colors.neutral) {
-    lines.push(`  --color-${n.name}: ${n.hex};`);
-  }
-  lines.push(`  --color-success: ${colors.semantic.success.hex};`);
-  lines.push(`  --color-warning: ${colors.semantic.warning.hex};`);
-  lines.push(`  --color-error: ${colors.semantic.error.hex};`);
-  lines.push(`  --color-info: ${colors.semantic.info.hex};`);
-  lines.push('');
-
-  lines.push(`  --font-heading: '${typography.headingFont}', sans-serif;`);
-  lines.push(`  --font-body: '${typography.bodyFont}', sans-serif;`);
-  lines.push(`  --font-mono: '${typography.monoFont}', monospace;`);
-  for (const step of typography.steps) {
-    lines.push(`  --text-${step.name}: ${step.size};`);
-    lines.push(`  --leading-${step.name}: ${step.lineHeight};`);
-  }
-  lines.push('');
-
-  for (const [key, value] of Object.entries(spacing.values)) {
-    lines.push(`  --spacing-${key}: ${value};`);
-  }
-
-  if (brand.shadows) {
-    lines.push('');
-    for (const [name, level] of Object.entries(brand.shadows.levels)) {
-      lines.push(`  --shadow-${name}: ${level.cssValue};`);
-    }
-  }
-
-  if (brand.borders) {
-    lines.push('');
-    for (const [name, value] of Object.entries(brand.borders.radii)) {
-      lines.push(`  --radius-${name}: ${value};`);
-    }
-    for (const [name, value] of Object.entries(brand.borders.widths)) {
-      lines.push(`  --border-${name}: ${value};`);
-    }
-  }
-
-  if (brand.motion) {
-    lines.push('');
-    for (const [name, value] of Object.entries(brand.motion.durations)) {
-      lines.push(`  --duration-${name}: ${value};`);
-    }
-    for (const [name, value] of Object.entries(brand.motion.easings)) {
-      lines.push(`  --ease-${name}: ${value};`);
-    }
-    for (const [name, value] of Object.entries(brand.motion.transitions)) {
-      lines.push(`  --transition-${name}: ${value};`);
-    }
-  }
-
-  if (brand.gradients) {
-    lines.push('');
-    for (const [name, gradient] of Object.entries(brand.gradients.presets)) {
-      lines.push(`  --gradient-${name}: ${gradient.cssValue};`);
-    }
-  }
-
-  lines.push('}');
-  return lines.join('\n');
-}

package/src/lib/branding-core/exporters/design-tokens.ts

@@ -1,86 +0,0 @@
-import type { BrandIdentity, DesignTokens } from '../../types.js';
-
-export function exportDesignTokens(brand: BrandIdentity): DesignTokens {
-  const { colors, typography, spacing } = brand;
-
-  const colorTokens: DesignTokens['color'] = {
-    primary: { value: { $value: colors.primary.hex, $type: 'color' } },
-    secondary: { value: { $value: colors.secondary.hex, $type: 'color' } },
-    accent: { value: { $value: colors.accent.hex, $type: 'color' } },
-    success: { value: { $value: colors.semantic.success.hex, $type: 'color' } },
-    warning: { value: { $value: colors.semantic.warning.hex, $type: 'color' } },
-    error: { value: { $value: colors.semantic.error.hex, $type: 'color' } },
-    info: { value: { $value: colors.semantic.info.hex, $type: 'color' } },
-  };
-
-  for (const neutral of colors.neutral) {
-    colorTokens[neutral.name] = { value: { $value: neutral.hex, $type: 'color' } };
-  }
-
-  const typographyTokens: DesignTokens['typography'] = {};
-  for (const step of typography.steps) {
-    typographyTokens[step.name] = {
-      fontSize: { $value: step.size, $type: 'dimension' },
-      lineHeight: { $value: step.lineHeight, $type: 'number' },
-      letterSpacing: { $value: step.letterSpacing, $type: 'dimension' },
-      fontWeight: { $value: step.weight, $type: 'number' },
-    };
-  }
-  typographyTokens['font-heading'] = {
-    value: { $value: typography.headingFont, $type: 'fontFamily' },
-  };
-  typographyTokens['font-body'] = {
-    value: { $value: typography.bodyFont, $type: 'fontFamily' },
-  };
-  typographyTokens['font-mono'] = {
-    value: { $value: typography.monoFont, $type: 'fontFamily' },
-  };
-
-  const spacingTokens: DesignTokens['spacing'] = {};
-  for (const [key, value] of Object.entries(spacing.values)) {
-    spacingTokens[key] = { $value: value, $type: 'dimension' };
-  }
-
-  const result: DesignTokens = {
-    $schema: 'https://design-tokens.github.io/community-group/format/',
-    color: colorTokens,
-    typography: typographyTokens,
-    spacing: spacingTokens,
-  };
-
-  if (brand.shadows) {
-    result.shadow = {};
-    for (const [name, level] of Object.entries(brand.shadows.levels)) {
-      result.shadow[name] = { $value: level.cssValue, $type: 'shadow' };
-    }
-  }
-
-  if (brand.borders) {
-    result.border = {};
-    for (const [name, value] of Object.entries(brand.borders.radii)) {
-      result.border[`radius-${name}`] = { $value: value, $type: 'dimension' };
-    }
-    for (const [name, value] of Object.entries(brand.borders.widths)) {
-      result.border[`width-${name}`] = { $value: value, $type: 'dimension' };
-    }
-  }
-
-  if (brand.motion) {
-    result.motion = {};
-    for (const [name, value] of Object.entries(brand.motion.durations)) {
-      result.motion[`duration-${name}`] = { $value: value, $type: 'duration' };
-    }
-    for (const [name, value] of Object.entries(brand.motion.easings)) {
-      result.motion[`easing-${name}`] = { $value: value, $type: 'cubicBezier' };
-    }
-  }
-
-  if (brand.gradients) {
-    result.gradient = {};
-    for (const [name, gradient] of Object.entries(brand.gradients.presets)) {
-      result.gradient[name] = { $value: gradient.cssValue, $type: 'gradient' };
-    }
-  }
-
-  return result;
-}

package/src/lib/branding-core/exporters/figma-tokens.ts

@@ -1,87 +0,0 @@
-import type { BrandIdentity } from '../../types.js';
-
-interface FigmaToken {
-  value: string | number;
-  type: string;
-  description?: string;
-}
-
-export function exportFigmaTokens(
-  brand: BrandIdentity
-): Record<string, Record<string, FigmaToken>> {
-  const { colors, typography, spacing } = brand;
-
-  const colorGroup: Record<string, FigmaToken> = {
-    primary: { value: colors.primary.hex, type: 'color', description: 'Primary brand color' },
-    secondary: { value: colors.secondary.hex, type: 'color' },
-    accent: { value: colors.accent.hex, type: 'color' },
-    success: { value: colors.semantic.success.hex, type: 'color' },
-    warning: { value: colors.semantic.warning.hex, type: 'color' },
-    error: { value: colors.semantic.error.hex, type: 'color' },
-    info: { value: colors.semantic.info.hex, type: 'color' },
-  };
-  for (const n of colors.neutral) {
-    colorGroup[n.name] = { value: n.hex, type: 'color' };
-  }
-
-  const typographyGroup: Record<string, FigmaToken> = {};
-  for (const step of typography.steps) {
-    typographyGroup[`${step.name}-size`] = { value: step.size, type: 'fontSizes' };
-    typographyGroup[`${step.name}-weight`] = { value: step.weight, type: 'fontWeights' };
-    typographyGroup[`${step.name}-lineHeight`] = { value: step.lineHeight, type: 'lineHeights' };
-  }
-  typographyGroup['font-heading'] = { value: typography.headingFont, type: 'fontFamilies' };
-  typographyGroup['font-body'] = { value: typography.bodyFont, type: 'fontFamilies' };
-  typographyGroup['font-mono'] = { value: typography.monoFont, type: 'fontFamilies' };
-
-  const spacingGroup: Record<string, FigmaToken> = {};
-  for (const [key, value] of Object.entries(spacing.values)) {
-    spacingGroup[key] = { value, type: 'spacing' };
-  }
-
-  const result: Record<string, Record<string, FigmaToken>> = {
-    color: colorGroup,
-    typography: typographyGroup,
-    spacing: spacingGroup,
-  };
-
-  if (brand.shadows) {
-    const shadowGroup: Record<string, FigmaToken> = {};
-    for (const [name, level] of Object.entries(brand.shadows.levels)) {
-      shadowGroup[name] = { value: level.cssValue, type: 'boxShadow' };
-    }
-    result.shadow = shadowGroup;
-  }
-
-  if (brand.borders) {
-    const borderGroup: Record<string, FigmaToken> = {};
-    for (const [name, value] of Object.entries(brand.borders.radii)) {
-      borderGroup[`radius-${name}`] = { value, type: 'borderRadius' };
-    }
-    for (const [name, value] of Object.entries(brand.borders.widths)) {
-      borderGroup[`width-${name}`] = { value, type: 'borderWidth' };
-    }
-    result.border = borderGroup;
-  }
-
-  if (brand.motion) {
-    const motionGroup: Record<string, FigmaToken> = {};
-    for (const [name, value] of Object.entries(brand.motion.durations)) {
-      motionGroup[`duration-${name}`] = { value, type: 'duration' };
-    }
-    for (const [name, value] of Object.entries(brand.motion.easings)) {
-      motionGroup[`easing-${name}`] = { value, type: 'other' };
-    }
-    result.motion = motionGroup;
-  }
-
-  if (brand.gradients) {
-    const gradientGroup: Record<string, FigmaToken> = {};
-    for (const [name, gradient] of Object.entries(brand.gradients.presets)) {
-      gradientGroup[name] = { value: gradient.cssValue, type: 'gradient' };
-    }
-    result.gradient = gradientGroup;
-  }
-
-  return result;
-}