aiox-core 5.0.4 → 5.0.5

package/pro/squads/design/scripts/design-system/curate_spacing.cjs

@@ -1,243 +0,0 @@
-#!/usr/bin/env node
-/**
- * GCD Base Unit + Harmonic Scale — Spacing Curation Pipeline
- *
- * Algorithm (from DS-CURATION-PIPELINE-PROPOSAL.md §4.2):
- *   1. Normalize units (rem → px)
- *   2. Calculate GCD of all values
- *   3. Default to 4px grid if GCD is anomalous
- *   4. Generate harmonic scale (0-96px, 13 steps)
- *   5. Map each value to nearest scale step
- *   6. Document unmapped values as overrides
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const ROOT = process.cwd();
-const EXTRACTION_DIR = path.join(ROOT, 'workspace', 'domains', 'design-system', 'extraction');
-const MERGED_PATH = path.join(EXTRACTION_DIR, 'all-pages-merged.json');
-const OUTPUT_DIR = path.join(EXTRACTION_DIR, 'curated');
-const OUTPUT_PATH = path.join(OUTPUT_DIR, 'curated-spacing.json');
-
-// ── Math helpers ───────────────────────────────────────────────────────────
-
-function gcd(a, b) {
-  a = Math.abs(Math.round(a));
-  b = Math.abs(Math.round(b));
-  while (b) {
-    [a, b] = [b, a % b];
-  }
-  return a;
-}
-
-function gcdArray(arr) {
-  return arr.reduce((acc, val) => gcd(acc, val), arr[0]);
-}
-
-// ── Harmonic Scale ─────────────────────────────────────────────────────────
-
-// Standard 4px grid scale (Tailwind-compatible)
-const SCALE = [
-  { name: '0', px: 0 },
-  { name: '0.5', px: 2 },
-  { name: '1', px: 4 },
-  { name: '1.5', px: 6 },
-  { name: '2', px: 8 },
-  { name: '2.5', px: 10 },
-  { name: '3', px: 12 },
-  { name: '3.5', px: 14 },
-  { name: '4', px: 16 },
-  { name: '5', px: 20 },
-  { name: '6', px: 24 },
-  { name: '7', px: 28 },
-  { name: '8', px: 32 },
-  { name: '9', px: 36 },
-  { name: '10', px: 40 },
-  { name: '11', px: 44 },
-  { name: '12', px: 48 },
-  { name: '14', px: 56 },
-  { name: '16', px: 64 },
-  { name: '20', px: 80 },
-  { name: '24', px: 96 },
-  { name: '28', px: 112 },
-  { name: '32', px: 128 },
-  { name: '36', px: 144 },
-  { name: '40', px: 160 },
-  { name: '44', px: 176 },
-  { name: '48', px: 192 },
-  { name: '52', px: 208 },
-  { name: '56', px: 224 },
-  { name: '60', px: 240 },
-  { name: '64', px: 256 },
-  { name: '72', px: 288 },
-  { name: '80', px: 320 },
-  { name: '96', px: 384 },
-];
-
-function findNearestStep(px) {
-  let best = SCALE[0];
-  let bestDist = Math.abs(px - best.px);
-
-  for (const step of SCALE) {
-    const dist = Math.abs(px - step.px);
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = step;
-    }
-  }
-
-  return { step: best, distance: bestDist };
-}
-
-// ── Main ───────────────────────────────────────────────────────────────────
-
-function main() {
-  console.log('=== SPACING CURATION PIPELINE ===\n');
-
-  const merged = JSON.parse(fs.readFileSync(MERGED_PATH, 'utf8'));
-  const rawSpacings = merged.spacings || [];
-
-  console.log(`Input: ${rawSpacings.length} unique spacing values from ${merged.meta.pagesIncluded} pages`);
-
-  // Extract unique px values with usage counts
-  const valueMap = new Map(); // px → { count, types[], contexts[] }
-  for (const sp of rawSpacings) {
-    const px = Math.round(sp.value);
-    if (px < 0) continue; // Skip negative values
-    const entry = valueMap.get(px) || { px, count: 0, types: new Set(), contexts: new Set() };
-    entry.count += sp.count || 0;
-    entry.types.add(sp.type || 'unknown');
-    if (sp.contexts) sp.contexts.forEach((c) => entry.contexts.add(c));
-    valueMap.set(px, entry);
-  }
-
-  const uniqueValues = [...valueMap.values()].sort((a, b) => a.px - b.px);
-  console.log(`  Unique pixel values: ${uniqueValues.length}`);
-
-  // Calculate GCD
-  const positiveValues = uniqueValues.filter((v) => v.px > 0).map((v) => v.px);
-  let detectedGcd = positiveValues.length > 0 ? gcdArray(positiveValues) : 4;
-
-  // Validate GCD
-  let baseUnit = detectedGcd;
-  let gcdStatus = 'auto';
-  if (detectedGcd !== 4 && detectedGcd !== 8 && detectedGcd !== 2) {
-    baseUnit = 4; // Default to 4px (Workshop rule)
-    gcdStatus = 'override';
-    console.log(`  GCD detected: ${detectedGcd}px → Overriding to 4px (market standard)`);
-  } else {
-    console.log(`  GCD detected: ${detectedGcd}px → Using as base unit`);
-  }
-
-  // Map each value to nearest scale step
-  const MAX_DISTANCE = 2; // Values > 2px from scale step → override
-  const decisions = [];
-  const mapped = [];
-  const overrides = [];
-  const usedSteps = new Map(); // step name → accumulated count
-
-  const totalUsage = uniqueValues.reduce((sum, v) => sum + v.count, 0);
-  let mappedUsage = 0;
-
-  for (const val of uniqueValues) {
-    const { step, distance } = findNearestStep(val.px);
-
-    if (distance <= MAX_DISTANCE) {
-      mapped.push({
-        originalPx: val.px,
-        mappedTo: step.name,
-        mappedPx: step.px,
-        distance,
-        count: val.count,
-        types: [...val.types],
-      });
-      mappedUsage += val.count;
-
-      const acc = usedSteps.get(step.name) || { step: step.name, px: step.px, count: 0 };
-      acc.count += val.count;
-      usedSteps.set(step.name, acc);
-
-      if (distance > 0) {
-        decisions.push({
-          category: 'spacing',
-          action: 'MAP',
-          items: [`${val.px}px`],
-          result: `${step.px}px (step ${step.name})`,
-          reason: `Distance ${distance}px <= ${MAX_DISTANCE}px threshold, mapped to nearest scale step`,
-          authority: 'Workshop 2026-02-16 — 4px grid market standard',
-        });
-      }
-    } else {
-      overrides.push({
-        originalPx: val.px,
-        nearestStep: step.name,
-        nearestPx: step.px,
-        distance,
-        count: val.count,
-        types: [...val.types],
-        contexts: [...val.contexts].slice(0, 3),
-      });
-    }
-  }
-
-  // Build final scale (only steps that are actually used + essential ones)
-  const essentialSteps = ['0', '1', '2', '3', '4', '6', '8', '10', '12', '16', '20', '24'];
-  const finalScale = SCALE.filter(
-    (s) => usedSteps.has(s.name) || essentialSteps.includes(s.name)
-  ).map((s) => ({
-    name: s.name,
-    px: s.px,
-    rem: Math.round((s.px / 16) * 10000) / 10000,
-    cssVar: `--spacing-${s.name.replace('.', '_')}`,
-    usage: usedSteps.get(s.name)?.count || 0,
-  }));
-
-  // Stats
-  const coverage = (mappedUsage / totalUsage) * 100;
-  const reduction = ((uniqueValues.length - finalScale.length) / uniqueValues.length) * 100;
-
-  const scores = {
-    before: uniqueValues.length,
-    after: finalScale.length,
-    reduction: `${Math.round(reduction * 10) / 10}%`,
-    target: '60%',
-    status: reduction >= 60 ? 'PASS' : reduction >= 40 ? 'CONDITIONAL' : 'FAIL',
-    base_unit: `${baseUnit}px`,
-    base_unit_status: gcdStatus === 'auto' ? 'PASS' : 'CONDITIONAL',
-    coverage: `${Math.round(coverage * 10) / 10}%`,
-    coverage_status: coverage >= 95 ? 'PASS' : coverage >= 85 ? 'CONDITIONAL' : 'FAIL',
-    overrides_count: overrides.length,
-  };
-
-  const output = {
-    meta: {
-      source: 'all-pages-merged.json',
-      pagesIncluded: merged.meta.pagesIncluded,
-      curatedAt: new Date().toISOString(),
-      algorithm: 'GCD base unit + harmonic scale mapping',
-      baseUnit: baseUnit,
-      detectedGcd: detectedGcd,
-    },
-    scores,
-    scale: finalScale,
-    overrides: overrides.sort((a, b) => b.count - a.count),
-    decisions,
-  };
-
-  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
-  fs.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
-
-  console.log(`\n--- RESULTS ---`);
-  console.log(`  Before: ${scores.before} unique values`);
-  console.log(`  After:  ${scores.after} scale steps`);
-  console.log(`  Reduction: ${scores.reduction} (target: ${scores.target}) → ${scores.status}`);
-  console.log(`  Base unit: ${scores.base_unit} (${scores.base_unit_status})`);
-  console.log(`  Coverage: ${scores.coverage} → ${scores.coverage_status}`);
-  console.log(`  Overrides: ${scores.overrides_count}`);
-  console.log(`  Decisions logged: ${decisions.length}`);
-  console.log(`\nOutput: ${OUTPUT_PATH}`);
-  console.log('=== DONE ===');
-}
-
-main();

package/pro/squads/design/scripts/design-system/curate_typography.cjs

@@ -1,404 +0,0 @@
-#!/usr/bin/env node
-/**
- * Modular Scale + Font Consolidation — Typography Curation Pipeline
- *
- * Algorithm (from DS-CURATION-PIPELINE-PROPOSAL.md §4.3):
- *   1. Count frequency of each font family → pick top 2 + 1 mono
- *   2. Detect modular scale multiplier, generate size scale
- *   3. Consolidate weights (max 5)
- *   4. Calculate ideal line-height ratios
- *   5. Consolidate letter-spacing
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const ROOT = process.cwd();
-const EXTRACTION_DIR = path.join(ROOT, 'workspace', 'domains', 'design-system', 'extraction');
-const MERGED_PATH = path.join(EXTRACTION_DIR, 'all-pages-merged.json');
-const STYLES_PATH = path.join(EXTRACTION_DIR, 'figma-styles.json');
-const OUTPUT_DIR = path.join(EXTRACTION_DIR, 'curated');
-const OUTPUT_PATH = path.join(OUTPUT_DIR, 'curated-typography.json');
-
-// ── Size Scale (Tailwind-compatible) ───────────────────────────────────────
-
-const SIZE_SCALE = [
-  { name: 'xs', px: 12 },
-  { name: 'sm', px: 14 },
-  { name: 'base', px: 16 },
-  { name: 'lg', px: 18 },
-  { name: 'xl', px: 20 },
-  { name: '2xl', px: 24 },
-  { name: '3xl', px: 30 },
-  { name: '4xl', px: 36 },
-  { name: '5xl', px: 48 },
-  { name: '6xl', px: 60 },
-  { name: '7xl', px: 72 },
-  { name: '8xl', px: 96 },
-  { name: '9xl', px: 128 },
-];
-
-// ── Weight consolidation ───────────────────────────────────────────────────
-
-const CANONICAL_WEIGHTS = [
-  { name: 'light', value: 300 },
-  { name: 'normal', value: 400 },
-  { name: 'medium', value: 500 },
-  { name: 'semibold', value: 600 },
-  { name: 'bold', value: 700 },
-];
-
-function findNearestWeight(w) {
-  let best = CANONICAL_WEIGHTS[0];
-  let bestDist = Math.abs(w - best.value);
-  for (const cw of CANONICAL_WEIGHTS) {
-    const dist = Math.abs(w - cw.value);
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = cw;
-    }
-  }
-  return { canonical: best, distance: bestDist };
-}
-
-// ── Line-height ratios ────────────────────────────────────────────────────
-
-const LH_RATIOS = [
-  { name: 'none', value: 1.0 },
-  { name: 'tight', value: 1.25 },
-  { name: 'snug', value: 1.375 },
-  { name: 'normal', value: 1.5 },
-  { name: 'relaxed', value: 1.625 },
-  { name: 'loose', value: 2.0 },
-];
-
-function findNearestLineHeight(ratio) {
-  let best = LH_RATIOS[0];
-  let bestDist = Math.abs(ratio - best.value);
-  for (const lh of LH_RATIOS) {
-    const dist = Math.abs(ratio - lh.value);
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = lh;
-    }
-  }
-  return best;
-}
-
-// ── Letter-spacing ─────────────────────────────────────────────────────────
-
-const LS_SCALE = [
-  { name: 'tighter', em: -0.05 },
-  { name: 'tight', em: -0.025 },
-  { name: 'normal', em: 0 },
-  { name: 'wide', em: 0.025 },
-  { name: 'wider', em: 0.05 },
-  { name: 'widest', em: 0.1 },
-];
-
-// ── Mono font detection ───────────────────────────────────────────────────
-
-const MONO_PATTERNS = /mono|code|console|courier|fira\s*code|jet\s*brains|source\s*code|menlo|hack|inconsolata/i;
-
-// ── Main ───────────────────────────────────────────────────────────────────
-
-function main() {
-  console.log('=== TYPOGRAPHY CURATION PIPELINE ===\n');
-
-  const merged = JSON.parse(fs.readFileSync(MERGED_PATH, 'utf8'));
-  const rawFonts = merged.fonts || [];
-  const rawTextStyles = merged.textStyles || [];
-
-  // Load Figma styles for enrichment
-  let figmaStyles = [];
-  try { figmaStyles = JSON.parse(fs.readFileSync(STYLES_PATH, 'utf8')); } catch (_) { /* optional */ }
-  const textFigmaStyles = figmaStyles.filter((s) => s.style_type === 'TEXT');
-  console.log(`  Figma text styles: ${textFigmaStyles.length}`);
-
-  // Analyze text decoration and text case usage from enriched textStyles
-  const decorationMap = new Map();
-  const textCaseMap = new Map();
-  for (const ts of rawTextStyles) {
-    const dec = ts.textDecoration || 'NONE';
-    decorationMap.set(dec, (decorationMap.get(dec) || 0) + (ts.count || 0));
-    const tc = ts.textCase || 'ORIGINAL';
-    textCaseMap.set(tc, (textCaseMap.get(tc) || 0) + (ts.count || 0));
-  }
-
-  console.log(`Input: ${rawFonts.length} font entries, ${rawTextStyles.length} text styles`);
-
-  // 1. Font families — count frequency
-  const familyMap = new Map(); // family → total count
-  for (const font of rawFonts) {
-    const family = (font.family || '').trim();
-    if (!family) continue;
-    familyMap.set(family, (familyMap.get(family) || 0) + (font.count || 0));
-  }
-
-  const sortedFamilies = [...familyMap.entries()]
-    .sort((a, b) => b[1] - a[1])
-    .map(([name, count]) => ({ name, count, isMono: MONO_PATTERNS.test(name) }));
-
-  console.log(`  Unique families: ${sortedFamilies.length}`);
-
-  // Select top 2 display/body + 1 mono
-  const monoFamilies = sortedFamilies.filter((f) => f.isMono);
-  const nonMonoFamilies = sortedFamilies.filter((f) => !f.isMono);
-
-  const selectedFamilies = [];
-  if (nonMonoFamilies.length >= 1) selectedFamilies.push({ ...nonMonoFamilies[0], role: 'primary' });
-  if (nonMonoFamilies.length >= 2) selectedFamilies.push({ ...nonMonoFamilies[1], role: 'secondary' });
-  if (monoFamilies.length >= 1) selectedFamilies.push({ ...monoFamilies[0], role: 'mono' });
-
-  // Rejected families (< 5% usage)
-  const totalFontUsage = sortedFamilies.reduce((sum, f) => sum + f.count, 0);
-  const rejectedFamilies = sortedFamilies
-    .filter((f) => !selectedFamilies.some((s) => s.name === f.name))
-    .filter((f) => (f.count / totalFontUsage) < 0.05)
-    .map((f) => ({
-      name: f.name,
-      count: f.count,
-      percentage: `${Math.round((f.count / totalFontUsage) * 1000) / 10}%`,
-    }));
-
-  console.log(`  Selected families: ${selectedFamilies.map((f) => f.name).join(', ')}`);
-  console.log(`  Rejected families: ${rejectedFamilies.length}`);
-
-  // 2. Font sizes — map to scale
-  const sizeMap = new Map(); // px → count
-  for (const ts of rawTextStyles) {
-    const size = Math.round(ts.fontSize || 0);
-    if (size <= 0) continue;
-    sizeMap.set(size, (sizeMap.get(size) || 0) + (ts.count || 0));
-  }
-
-  const uniqueSizes = [...sizeMap.entries()]
-    .sort((a, b) => a[0] - b[0])
-    .map(([px, count]) => ({ px, count }));
-
-  console.log(`  Unique sizes: ${uniqueSizes.length}`);
-
-  // Map each size to nearest scale step
-  const sizeMappings = [];
-  const usedSizeSteps = new Map();
-
-  for (const { px, count } of uniqueSizes) {
-    let bestStep = SIZE_SCALE[0];
-    let bestDist = Math.abs(px - bestStep.px);
-
-    for (const step of SIZE_SCALE) {
-      const dist = Math.abs(px - step.px);
-      if (dist < bestDist) {
-        bestDist = dist;
-        bestStep = step;
-      }
-    }
-
-    sizeMappings.push({
-      originalPx: px,
-      mappedTo: bestStep.name,
-      mappedPx: bestStep.px,
-      distance: bestDist,
-      count,
-    });
-
-    const acc = usedSizeSteps.get(bestStep.name) || { ...bestStep, count: 0, rem: bestStep.px / 16 };
-    acc.count += count;
-    usedSizeSteps.set(bestStep.name, acc);
-  }
-
-  // Final size scale (used + essential)
-  const essentialSizes = ['xs', 'sm', 'base', 'lg', 'xl', '2xl', '3xl', '4xl', '5xl'];
-  const finalSizeScale = SIZE_SCALE
-    .filter((s) => usedSizeSteps.has(s.name) || essentialSizes.includes(s.name))
-    .map((s) => ({
-      name: s.name,
-      px: s.px,
-      rem: s.px / 16,
-      cssVar: `--font-size-${s.name}`,
-      usage: usedSizeSteps.get(s.name)?.count || 0,
-    }));
-
-  // 3. Weights — consolidate
-  const weightMap = new Map();
-  for (const ts of rawTextStyles) {
-    const w = ts.fontWeight || 400;
-    weightMap.set(w, (weightMap.get(w) || 0) + (ts.count || 0));
-  }
-
-  const decisions = [];
-  const weightMappings = [];
-  const usedWeights = new Map();
-
-  for (const [w, count] of weightMap) {
-    const { canonical, distance } = findNearestWeight(w);
-    weightMappings.push({
-      original: w,
-      mappedTo: canonical.name,
-      mappedValue: canonical.value,
-      distance,
-      count,
-    });
-
-    const acc = usedWeights.get(canonical.name) || { ...canonical, count: 0 };
-    acc.count += count;
-    usedWeights.set(canonical.name, acc);
-
-    if (distance > 0) {
-      decisions.push({
-        category: 'typography',
-        action: 'MAP_WEIGHT',
-        items: [`weight ${w}`],
-        result: `${canonical.name} (${canonical.value})`,
-        reason: `Distance ${distance} < 50 threshold`,
-        authority: 'DS-CURATION-PIPELINE-PROPOSAL §4.3',
-      });
-    }
-  }
-
-  const finalWeights = CANONICAL_WEIGHTS
-    .filter((w) => usedWeights.has(w.name))
-    .map((w) => ({
-      name: w.name,
-      value: w.value,
-      cssVar: `--font-weight-${w.name}`,
-      usage: usedWeights.get(w.name)?.count || 0,
-    }));
-
-  // 4. Line heights
-  const lhMap = new Map();
-  for (const ts of rawTextStyles) {
-    if (!ts.fontSize || !ts.lineHeight) continue;
-    const ratio = Math.round((ts.lineHeight / ts.fontSize) * 100) / 100;
-    lhMap.set(ratio, (lhMap.get(ratio) || 0) + (ts.count || 0));
-  }
-
-  const usedLineHeights = new Map();
-  for (const [ratio, count] of lhMap) {
-    const nearest = findNearestLineHeight(ratio);
-    const acc = usedLineHeights.get(nearest.name) || { ...nearest, count: 0 };
-    acc.count += count;
-    usedLineHeights.set(nearest.name, acc);
-  }
-
-  const finalLineHeights = LH_RATIOS
-    .filter((lh) => usedLineHeights.has(lh.name))
-    .map((lh) => ({
-      name: lh.name,
-      value: lh.value,
-      cssVar: `--line-height-${lh.name}`,
-      usage: usedLineHeights.get(lh.name)?.count || 0,
-    }));
-
-  // 5. Letter spacing
-  const lsMap = new Map();
-  for (const ts of rawTextStyles) {
-    const ls = ts.letterSpacing || 0;
-    const em = ts.fontSize ? Math.round((ls / ts.fontSize) * 1000) / 1000 : 0;
-    const key = Math.round(em * 100) / 100;
-    lsMap.set(key, (lsMap.get(key) || 0) + (ts.count || 0));
-  }
-
-  const finalLetterSpacing = LS_SCALE.map((ls) => ({
-    name: ls.name,
-    em: ls.em,
-    cssVar: `--letter-spacing-${ls.name}`,
-  }));
-
-  // Stats
-  const totalBefore = {
-    families: sortedFamilies.length,
-    sizes: uniqueSizes.length,
-    weights: weightMap.size,
-  };
-  const totalAfter = {
-    families: selectedFamilies.length,
-    sizes: finalSizeScale.length,
-    weights: finalWeights.length,
-  };
-
-  const reductionPct =
-    (1 -
-      (totalAfter.families + totalAfter.sizes + totalAfter.weights) /
-        (totalBefore.families + totalBefore.sizes + totalBefore.weights)) *
-    100;
-
-  const scores = {
-    before: totalBefore,
-    after: totalAfter,
-    reduction: `${Math.round(reductionPct * 10) / 10}%`,
-    target: '50%',
-    status: reductionPct >= 50 ? 'PASS' : reductionPct >= 35 ? 'CONDITIONAL' : 'FAIL',
-    families_status: totalAfter.families <= 3 ? 'PASS' : totalAfter.families === 4 ? 'CONDITIONAL' : 'FAIL',
-    weights_status: totalAfter.weights <= 5 ? 'PASS' : totalAfter.weights === 6 ? 'CONDITIONAL' : 'FAIL',
-  };
-
-  // Text decoration analysis
-  const textDecorations = [...decorationMap.entries()]
-    .filter(([k]) => k !== 'NONE')
-    .map(([name, count]) => ({ name, count }))
-    .sort((a, b) => b.count - a.count);
-
-  // Text case analysis
-  const textCases = [...textCaseMap.entries()]
-    .filter(([k]) => k !== 'ORIGINAL')
-    .map(([name, count]) => ({ name, count }))
-    .sort((a, b) => b.count - a.count);
-
-  // Paragraph spacing analysis
-  const paragraphSpacingMap = new Map();
-  for (const ts of rawTextStyles) {
-    const ps = ts.paragraphSpacing || 0;
-    if (ps > 0) {
-      paragraphSpacingMap.set(ps, (paragraphSpacingMap.get(ps) || 0) + (ts.count || 0));
-    }
-  }
-  const paragraphSpacings = [...paragraphSpacingMap.entries()]
-    .map(([value, count]) => ({ value, count }))
-    .sort((a, b) => b.count - a.count);
-
-  const output = {
-    meta: {
-      source: 'all-pages-merged.json',
-      pagesIncluded: merged.meta.pagesIncluded,
-      curatedAt: new Date().toISOString(),
-      algorithm: 'Modular scale + font consolidation',
-      figmaTextStylesCount: textFigmaStyles.length,
-    },
-    scores,
-    families: selectedFamilies.map((f) => ({
-      name: f.name,
-      role: f.role,
-      count: f.count,
-      percentage: `${Math.round((f.count / totalFontUsage) * 1000) / 10}%`,
-      cssVar: `--font-family-${f.role}`,
-    })),
-    rejectedFamilies,
-    sizeScale: finalSizeScale,
-    weights: finalWeights,
-    lineHeights: finalLineHeights,
-    letterSpacing: finalLetterSpacing,
-    textDecorations,
-    textCases,
-    paragraphSpacings,
-    decisions,
-  };
-
-  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
-  fs.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
-
-  console.log(`\n--- RESULTS ---`);
-  console.log(`  Families: ${totalBefore.families} → ${totalAfter.families} (${scores.families_status})`);
-  console.log(`  Sizes: ${totalBefore.sizes} → ${totalAfter.sizes}`);
-  console.log(`  Weights: ${totalBefore.weights} → ${totalAfter.weights} (${scores.weights_status})`);
-  console.log(`  Line heights: ${lhMap.size} → ${finalLineHeights.length}`);
-  console.log(`  Text decorations: ${textDecorations.length} non-default`);
-  console.log(`  Text cases: ${textCases.length} non-default`);
-  console.log(`  Paragraph spacings: ${paragraphSpacings.length} distinct values`);
-  console.log(`  Overall reduction: ${scores.reduction} (target: ${scores.target}) → ${scores.status}`);
-  console.log(`  Decisions logged: ${decisions.length}`);
-  console.log(`\nOutput: ${OUTPUT_PATH}`);
-  console.log('=== DONE ===');
-}
-
-main();

package/pro/squads/design/scripts/design-system/design-system-metadata.test.js

@@ -1,49 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-
-describe('design system metadata pipeline', () => {
-  test('generates metadata/components.json', () => {
-    const result = spawnSync('node', ['squads/design/scripts/design-system/generate_components_metadata.cjs'], {
-      encoding: 'utf8'
-    });
-
-    expect(result.status).toBe(0);
-    expect(existsSync('workspace/domains/design-system/metadata/components.json')).toBe(true);
-  });
-
-  test('validates metadata/components.json', () => {
-    const result = spawnSync('node', ['squads/design/scripts/design-system/validate_components_metadata.cjs'], {
-      encoding: 'utf8'
-    });
-
-    expect(result.status).toBe(0);
-    expect(result.stdout).toContain('PASS: validated');
-  });
-
-  test('validates MCP skeleton', () => {
-    const result = spawnSync('node', ['squads/design/scripts/design-system/validate_mcp_skeleton.cjs'], {
-      encoding: 'utf8'
-    });
-
-    expect(result.status).toBe(0);
-    expect(result.stdout).toContain('PASS: MCP skeleton');
-  });
-
-  test('syncs design manifest from squad.yaml', () => {
-    const result = spawnSync('node', ['squads/design/scripts/design-system/sync_design_manifest.cjs'], {
-      encoding: 'utf8'
-    });
-
-    expect(result.status).toBe(0);
-    expect(result.stdout).toContain('PASS: synced');
-  });
-
-  test('validates design manifest drift', () => {
-    const result = spawnSync('node', ['squads/design/scripts/design-system/validate_design_manifest_drift.cjs'], {
-      encoding: 'utf8'
-    });
-
-    expect(result.status).toBe(0);
-    expect(result.stdout).toContain('PASS: design manifest is synchronized');
-  });
-});