design-brain-memory 0.9.2 → 0.9.4

package/dist/taste.js

@@ -1,598 +1,411 @@
-import os from 'node:os';
-import path from 'node:path';
-import { ingestInspiration } from './commands.js';
-import { captureDesignFromUrl } from './extractFromUrl.js';
-import { runDesignLlm } from './llm.js';
+import { aggregateColors, aggregateTypography, aggregateComponents, aggregateMotion } from './aggregate.js';
+import { designAnalysisToScanTokens, computeScore, looksLikeUrl, normalizeToUrl, hueFromHex, saturationFromHex, lightnessFromHex } from './scan.js';
 import { assignPersona } from './persona.js';
-import { aggregateColors, aggregateComponents, aggregateMotion, aggregateTypography } from './render.js';
-import { computeScore, designAnalysisToScanTokens, looksLikeUrl, normalizeToUrl } from './scan.js';
-import { ensureProject, loadDatabase, saveDatabase, loadTasteProfile, saveTasteProfile } from './store.js';
-import { theatricalScan } from './theatrical.js';
-import { detectConflicts } from './tasteRefine.js';
-import { nowIso, unique } from './util.js';
-function asAnimationToken(token) {
-    return 'library' in token && 'motionIntent' in token;
-}
-function parseDurationMs(value) {
-    const matches = value.match(/(\d+(?:\.\d+)?)\s*(ms|s)\b/gi) ?? [];
-    return matches
-        .map((match) => {
-        const parsed = match.match(/(\d+(?:\.\d+)?)\s*(ms|s)\b/i);
-        if (!parsed) {
-            return null;
-        }
-        const numeric = Number.parseFloat(parsed[1]);
-        if (!Number.isFinite(numeric)) {
-            return null;
-        }
-        return parsed[2].toLowerCase() === 's' ? numeric * 1000 : numeric;
-    })
-        .filter((value) => value !== null);
-}
-function parseNumericValues(value) {
-    if (!value) {
-        return [];
-    }
-    return (value.match(/-?\d+(?:\.\d+)?/g) ?? [])
-        .map((entry) => Number.parseFloat(entry))
-        .filter((entry) => Number.isFinite(entry));
-}
-function parseFontSizeToPx(value) {
-    const text = value.trim().toLowerCase();
-    const match = text.match(/^(\d+(?:\.\d+)?)(px|rem|em)$/);
-    if (!match) {
-        return null;
-    }
-    const numeric = Number.parseFloat(match[1]);
-    if (!Number.isFinite(numeric)) {
-        return null;
-    }
-    if (match[2] === 'px') {
-        return numeric;
-    }
-    return numeric * 16;
-}
-function parseWeightValue(weight) {
-    const normalized = weight.trim().toLowerCase();
-    if (/^\d+$/.test(normalized)) {
-        return Number.parseInt(normalized, 10);
-    }
-    const map = {
-        normal: 400,
-        medium: 500,
-        semibold: 600,
-        bold: 700,
-    };
-    return map[normalized] ?? null;
-}
-function formatDuration(value) {
-    return `${Math.round(value)}ms`;
-}
-function resolveColorRole(index) {
-    const roles = ['primary', 'background', 'accent', 'text', 'surface'];
-    return roles[index] ?? `color-${index + 1}`;
-}
-function sourceForColor(hex, inspirations) {
-    const normalized = hex.toUpperCase();
-    let bestSource = 'aggregate';
-    let bestCount = -1;
-    for (const inspiration of inspirations) {
-        const match = inspiration.analysis.colors.find((color) => color.hex.toUpperCase() === normalized);
-        if (match && match.count > bestCount) {
-            bestCount = match.count;
-            bestSource = inspiration.url
-                ? (() => {
-                    try {
-                        return new URL(inspiration.url).hostname;
-                    }
-                    catch {
-                        return inspiration.url;
-                    }
-                })()
-                : inspiration.id;
-        }
-    }
-    return bestSource;
-}
-function hexToRgb(hex) {
-    const clean = hex.replace('#', '').trim();
-    if (!/^[0-9a-fA-F]{3}([0-9a-fA-F]{3})?$/.test(clean)) {
-        return null;
-    }
-    const full = clean.length === 3
-        ? `${clean[0]}${clean[0]}${clean[1]}${clean[1]}${clean[2]}${clean[2]}`
-        : clean;
-    return {
-        r: Number.parseInt(full.slice(0, 2), 16),
-        g: Number.parseInt(full.slice(2, 4), 16),
-        b: Number.parseInt(full.slice(4, 6), 16),
-    };
-}
-function rgbToHsl(rgb) {
-    const r = rgb.r / 255;
-    const g = rgb.g / 255;
-    const b = rgb.b / 255;
-    const max = Math.max(r, g, b);
-    const min = Math.min(r, g, b);
-    const l = (max + min) / 2;
-    if (max === min) {
-        return { h: 0, s: 0, l };
-    }
-    const d = max - min;
-    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-    let h = 0;
-    if (max === r) {
-        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
-    }
-    else if (max === g) {
-        h = ((b - r) / d + 2) / 6;
-    }
-    else {
-        h = ((r - g) / d + 4) / 6;
-    }
-    return { h: h * 360, s, l };
-}
-function hueDelta(a, b) {
-    const direct = Math.abs(a - b);
-    return Math.min(direct, 360 - direct);
-}
+import { loadDatabase, ensureProject, saveTasteProfile, loadTasteProfile } from './store.js';
+import { enrichWithLlm } from './llm.js';
+import { ingestInspiration } from './commands.js';
+import { nowIso } from './util.js';
+// ── Derive functions ───────────────────────────────────────
 function classifyHarmony(hues) {
-    if (hues.length <= 1) {
+    if (hues.length <= 1)
         return 'monochromatic';
-    }
-    const deltas = [];
-    for (let i = 0; i < hues.length; i += 1) {
-        for (let j = i + 1; j < hues.length; j += 1) {
-            deltas.push(hueDelta(hues[i], hues[j]));
-        }
-    }
-    if (deltas.some((value) => value >= 150 && value <= 210)) {
-        return 'complementary';
-    }
-    const averageDelta = deltas.reduce((sum, value) => sum + value, 0) / deltas.length;
-    if (averageDelta <= 45) {
+    const sorted = [...hues].sort((a, b) => a - b);
+    const gaps = [];
+    for (let i = 1; i < sorted.length; i++) {
+        gaps.push(sorted[i] - sorted[i - 1]);
+    }
+    gaps.push(360 - sorted[sorted.length - 1] + sorted[0]);
+    const maxGap = Math.max(...gaps);
+    const minGap = Math.min(...gaps);
+    const avgGap = 360 / hues.length;
+    const spread = maxGap - minGap;
+    if (spread < 40)
         return 'analogous';
-    }
-    return 'triadic';
+    if (hues.length === 2 && Math.abs(gaps[0] - 180) < 30)
+        return 'complementary';
+    if (hues.length === 3 && Math.abs(avgGap - 120) < 25)
+        return 'triadic';
+    if (maxGap > 200)
+        return 'split-complementary';
+    return 'analogous';
 }
 function deriveColorPreference(colors, inspirations) {
-    const palette = colors
-        .slice(0, 5)
-        .map((color, index) => ({
-        hex: color.hex.toUpperCase(),
-        role: resolveColorRole(index),
-        source: sourceForColor(color.hex, inspirations),
-    }));
-    if (palette.length === 0) {
-        palette.push({ hex: '#111111', role: 'primary', source: 'default' }, { hex: '#FFFFFF', role: 'surface', source: 'default' });
+    const palette = [];
+    const roles = ['primary', 'secondary', 'accent', 'background', 'text', 'surface'];
+    for (let i = 0; i < Math.min(colors.length, roles.length); i++) {
+        const color = colors[i];
+        const source = inspirations.find((ins) => ins.analysis.colors.some((c) => c.hex.toUpperCase() === color.hex.toUpperCase()));
+        palette.push({
+            hex: color.hex,
+            role: roles[i],
+            source: source?.url ?? source?.name ?? 'unknown',
+        });
     }
-    const hslValues = palette
-        .map((entry) => hexToRgb(entry.hex))
-        .filter((entry) => entry !== null)
-        .map(rgbToHsl);
-    const hues = hslValues.map((value) => value.h);
-    const sats = hslValues.map((value) => value.s);
-    const lights = hslValues.map((value) => value.l);
-    const hueRange = {
-        min: Math.round(Math.min(...(hues.length > 0 ? hues : [0]))),
-        max: Math.round(Math.max(...(hues.length > 0 ? hues : [0]))),
-    };
-    const avgSat = sats.length > 0 ? sats.reduce((sum, value) => sum + value, 0) / sats.length : 0;
-    const avgLight = lights.length > 0 ? lights.reduce((sum, value) => sum + value, 0) / lights.length : 0;
+    const validHexes = colors
+        .filter((c) => c.hex.length === 7)
+        .slice(0, 12);
+    const hues = [...new Set(validHexes.map((c) => Math.round(hueFromHex(c.hex) / 30) * 30))];
+    const saturations = validHexes.map((c) => saturationFromHex(c.hex));
+    const lightnesses = validHexes.map((c) => lightnessFromHex(c.hex));
+    const avgSat = saturations.length > 0
+        ? saturations.reduce((a, b) => a + b, 0) / saturations.length
+        : 0.5;
+    const avgLight = lightnesses.length > 0
+        ? lightnesses.reduce((a, b) => a + b, 0) / lightnesses.length
+        : 0.5;
+    const allHues = validHexes.map((c) => hueFromHex(c.hex));
+    const minHue = allHues.length > 0 ? Math.min(...allHues) : 0;
+    const maxHue = allHues.length > 0 ? Math.max(...allHues) : 360;
     return {
         palette,
         harmony: classifyHarmony(hues),
-        hueRange,
-        saturationBias: avgSat >= 0.62 ? 'vibrant' : avgSat <= 0.35 ? 'muted' : 'neutral',
-        lightnessBias: avgLight >= 0.7 ? 'light' : avgLight <= 0.33 ? 'dark' : 'balanced',
+        hueRange: { min: Math.round(minHue), max: Math.round(maxHue) },
+        saturationBias: avgSat > 0.6 ? 'vibrant' : avgSat < 0.3 ? 'muted' : 'neutral',
+        lightnessBias: avgLight > 0.65 ? 'light' : avgLight < 0.35 ? 'dark' : 'balanced',
     };
 }
 function deriveTypographyPreference(typography) {
-    const familyCounts = new Map();
-    for (const token of typography) {
-        familyCounts.set(token.fontFamily, (familyCounts.get(token.fontFamily) ?? 0) + token.count);
-    }
-    const families = [...familyCounts.entries()]
-        .sort((a, b) => b[1] - a[1])
-        .map((entry) => entry[0]);
-    const primaryFont = families[0] ?? 'Inter';
-    const secondaryFont = families[1] ?? null;
-    const sizeSet = unique(typography
-        .map((token) => token.fontSize.trim())
-        .filter((size) => size.length > 0));
-    const sizes = sizeSet.sort((a, b) => {
-        const pa = parseFontSizeToPx(a);
-        const pb = parseFontSizeToPx(b);
-        if (pa === null && pb === null) {
-            return a.localeCompare(b);
-        }
-        if (pa === null) {
-            return 1;
-        }
-        if (pb === null) {
-            return -1;
-        }
-        return pa - pb;
-    });
-    const pxSizes = sizes
-        .map(parseFontSizeToPx)
-        .filter((value) => value !== null)
+    const familyCount = new Map();
+    for (const t of typography) {
+        const fam = t.fontFamily.toLowerCase();
+        familyCount.set(fam, (familyCount.get(fam) ?? 0) + t.count);
+    }
+    const sorted = [...familyCount.entries()].sort((a, b) => b[1] - a[1]);
+    const primaryFont = sorted[0]?.[0] ?? 'system-ui';
+    const secondaryFont = sorted[1]?.[0] ?? null;
+    const sizes = [...new Set(typography.map((t) => t.fontSize))];
+    const numericSizes = sizes
+        .map((s) => parseFloat(s))
+        .filter((n) => !isNaN(n))
         .sort((a, b) => a - b);
-    const ratios = [];
-    for (let i = 1; i < pxSizes.length; i += 1) {
-        if (pxSizes[i - 1] > 0) {
-            ratios.push(pxSizes[i] / pxSizes[i - 1]);
+    let scaleType = 'custom';
+    if (numericSizes.length >= 3) {
+        const ratios = [];
+        for (let i = 1; i < numericSizes.length; i++) {
+            ratios.push(numericSizes[i] / numericSizes[i - 1]);
         }
-    }
-    const avgRatio = ratios.length > 0
-        ? ratios.reduce((sum, value) => sum + value, 0) / ratios.length
-        : 0;
-    const ratioVariance = ratios.length > 0
-        ? ratios.reduce((sum, value) => sum + Math.abs(value - avgRatio), 0) / ratios.length
-        : 1;
-    const weightValues = typography
-        .map((token) => token.fontWeight.trim())
-        .filter((weight) => weight.length > 0);
-    const numericWeights = weightValues
-        .map(parseWeightValue)
-        .filter((value) => value !== null)
-        .sort((a, b) => a - b);
-    const minWeight = numericWeights[0]?.toString() ?? weightValues[0] ?? '400';
-    const maxWeight = numericWeights[numericWeights.length - 1]?.toString() ?? weightValues.at(-1) ?? '700';
+        const avgRatio = ratios.reduce((a, b) => a + b, 0) / ratios.length;
+        if (Math.abs(avgRatio - 1.25) < 0.1)
+            scaleType = 'major-third';
+        else if (Math.abs(avgRatio - 1.333) < 0.1)
+            scaleType = 'perfect-fourth';
+        else if (Math.abs(avgRatio - 1.5) < 0.1)
+            scaleType = 'perfect-fifth';
+        else if (Math.abs(avgRatio - 1.618) < 0.15)
+            scaleType = 'golden-ratio';
+        else
+            scaleType = 'linear';
+    }
+    const weights = typography.map((t) => t.fontWeight).filter((w) => w !== 'unknown');
+    const numericWeights = weights.map((w) => parseInt(w, 10)).filter((n) => !isNaN(n)).sort((a, b) => a - b);
     return {
         primaryFont,
         secondaryFont,
-        scaleType: sizes.length <= 2 ? 'tailwind-default' : ratioVariance <= 0.2 ? 'modular' : 'custom',
-        sizes,
+        scaleType,
+        sizes: sizes.slice(0, 8),
         weightRange: {
-            min: minWeight,
-            max: maxWeight,
+            min: numericWeights[0]?.toString() ?? '400',
+            max: numericWeights[numericWeights.length - 1]?.toString() ?? '700',
         },
     };
 }
 function deriveSpacingPreference(components) {
-    const values = components
-        .flatMap((component) => [
-        component.styles.padding,
-        component.styles.margin,
-        component.styles.gap,
-        component.styles.rowGap,
-        component.styles.columnGap,
-    ])
-        .flatMap(parseNumericValues)
-        .filter((value) => value > 0);
-    const baseAligned4 = values.filter((value) => value % 4 === 0).length;
-    const baseAligned8 = values.filter((value) => value % 8 === 0).length;
-    const baseUnit = baseAligned8 >= baseAligned4 ? 8 : 4;
+    const spacingProps = [
+        'padding', 'padding-top', 'padding-right', 'padding-bottom', 'padding-left',
+        'margin', 'margin-top', 'margin-right', 'margin-bottom', 'margin-left',
+        'gap', 'row-gap', 'column-gap',
+    ];
+    const values = [];
+    for (const comp of components) {
+        for (const prop of spacingProps) {
+            const val = comp.styles[prop];
+            if (!val)
+                continue;
+            const nums = val.match(/(\d+(?:\.\d+)?)/g);
+            if (nums) {
+                for (const n of nums) {
+                    const parsed = parseFloat(n);
+                    if (parsed > 0 && parsed < 200)
+                        values.push(parsed);
+                }
+            }
+        }
+    }
+    if (values.length === 0) {
+        return { baseUnit: 8, scale: [4, 8, 12, 16, 24, 32, 48, 64], gridAlignmentRatio: 0 };
+    }
+    const mod4 = values.filter((v) => v % 4 === 0).length;
+    const mod8 = values.filter((v) => v % 8 === 0).length;
+    const baseUnit = mod8 / values.length > 0.6 ? 8 : 4;
+    const uniqueValues = [...new Set(values)].sort((a, b) => a - b);
+    const scale = uniqueValues
+        .filter((v) => v % baseUnit === 0)
+        .slice(0, 10);
     const gridAlignmentRatio = values.length > 0
-        ? values.filter((value) => value % baseUnit === 0).length / values.length
-        : 1;
-    const scale = unique(values.map((value) => Math.round(value)))
-        .sort((a, b) => a - b)
-        .slice(0, 12);
-    const fallbackScale = baseUnit === 8
-        ? [4, 8, 12, 16, 24, 32, 48, 64]
-        : [4, 8, 12, 16, 20, 24, 32, 40];
+        ? Math.round((mod4 / values.length) * 100) / 100
+        : 0;
     return {
         baseUnit,
-        scale: scale.length > 0 ? scale : fallbackScale,
-        gridAlignmentRatio: Number(gridAlignmentRatio.toFixed(2)),
+        scale: scale.length > 0 ? scale : [4, 8, 12, 16, 24, 32, 48, 64],
+        gridAlignmentRatio,
     };
 }
 function deriveMotionPreference(motion) {
-    const easings = new Map();
-    const durations = [];
-    for (const token of motion) {
-        if (asAnimationToken(token)) {
-            if (token.timing) {
-                durations.push(token.timing.duration);
-                const easing = token.timing.easing.trim();
-                if (easing) {
-                    easings.set(easing, (easings.get(easing) ?? 0) + token.count);
-                }
+    if (motion.length === 0) {
+        return { easing: 'ease', durations: [], intensity: 'none' };
+    }
+    const easingCount = new Map();
+    const durationCount = new Map();
+    for (const m of motion) {
+        // Extract easing from raw string first (structured fields may have split cubic-bezier on commas)
+        let easingFromRaw = null;
+        if (m.transition && m.transition !== 'none' && m.transition !== 'all') {
+            const cubicMatch = m.transition.match(/cubic-bezier\([^)]+\)/);
+            if (cubicMatch) {
+                easingFromRaw = cubicMatch[0];
+            }
+            else {
+                const keyword = m.transition.match(/\b(ease-in-out|ease-in|ease-out|ease|linear)\b/);
+                if (keyword)
+                    easingFromRaw = keyword[0];
             }
-            continue;
-        }
-        for (const duration of parseDurationMs(token.transition)) {
-            durations.push(duration);
         }
-        for (const duration of parseDurationMs(token.animation)) {
-            durations.push(duration);
+        if (easingFromRaw) {
+            easingCount.set(easingFromRaw, (easingCount.get(easingFromRaw) ?? 0) + m.count);
         }
-        const easingCandidates = token.transition.match(/(?:ease(?:-in|-out|-in-out)?|linear|cubic-bezier\([^)]+\))/g) ?? [];
-        for (const easing of easingCandidates) {
-            easings.set(easing, (easings.get(easing) ?? 0) + token.count);
+        else {
+            // Fall back to structured fields only if raw string didn't yield a result
+            for (const t of m.transitions ?? []) {
+                if (t.timingFunction && t.timingFunction.length > 3) {
+                    easingCount.set(t.timingFunction, (easingCount.get(t.timingFunction) ?? 0) + m.count);
+                }
+            }
+            for (const a of m.animations ?? []) {
+                if (a.timingFunction && a.timingFunction.length > 3) {
+                    easingCount.set(a.timingFunction, (easingCount.get(a.timingFunction) ?? 0) + m.count);
+                }
+            }
         }
-    }
-    const dominantEasing = [...easings.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 'ease';
-    const uniqueDurations = unique(durations.map((value) => Math.round(value))).sort((a, b) => a - b);
-    const durationLabels = uniqueDurations.slice(0, 6).map(formatDuration);
-    const count = motion.length;
-    const intensity = count === 0
-        ? 'none'
-        : count <= 12
-            ? 'subtle'
-            : count <= 40
-                ? 'moderate'
-                : 'expressive';
-    return {
-        easing: dominantEasing,
-        durations: durationLabels.length > 0 ? durationLabels : ['200ms'],
-        intensity,
-    };
-}
-function deriveComponentPreference(components) {
-    const radiusValues = components
-        .flatMap((component) => parseNumericValues(component.styles.borderRadius))
-        .filter((value) => value >= 0)
-        .sort((a, b) => a - b);
-    const medianRadius = radiusValues.length > 0
-        ? radiusValues[Math.floor(radiusValues.length / 2)]
-        : 8;
-    const shadows = components
-        .map((component) => component.styles.boxShadow?.trim())
-        .filter((shadow) => Boolean(shadow && shadow !== 'none'));
-    const noneCount = components.length - shadows.length;
-    const shadowStyle = shadows.length === 0
-        ? 'none'
-        : shadows.length <= noneCount
-            ? 'subtle'
-            : shadows.some((shadow) => /(?:\b2\dpx\b|\b3\dpx\b|\b4\dpx\b|rgba?\([^)]*,\s*0\.[45-9])/i.test(shadow))
-                ? 'dramatic'
-                : 'elevated';
-    return {
-        cherryPicks: [],
-        borderRadius: `${Math.round(medianRadius)}px`,
-        shadowStyle,
-    };
-}
-function buildAggregateTokens(inspirations) {
-    const colors = aggregateColors(inspirations);
-    const typography = aggregateTypography(inspirations);
-    const components = aggregateComponents(inspirations);
-    const motion = aggregateMotion(inspirations);
-    const transitionValues = motion.flatMap((token) => {
-        if (asAnimationToken(token)) {
-            if (!token.timing) {
-                return [];
+        // Durations: prefer structured, fall back to raw
+        let gotDuration = false;
+        for (const t of m.transitions ?? []) {
+            if (t.duration && t.duration !== '0s') {
+                durationCount.set(t.duration, (durationCount.get(t.duration) ?? 0) + m.count);
+                gotDuration = true;
             }
-            return [`${token.motionIntent} ${token.timing.duration}ms ${token.timing.easing}`];
         }
-        const values = [];
-        if (token.transition && token.transition !== 'all 0s ease 0s') {
-            values.push(token.transition);
+        for (const a of m.animations ?? []) {
+            if (a.duration && a.duration !== '0s') {
+                durationCount.set(a.duration, (durationCount.get(a.duration) ?? 0) + m.count);
+                gotDuration = true;
+            }
         }
-        if (token.animation && token.animation !== 'none') {
-            values.push(token.animation);
+        if (!gotDuration && m.transition && m.transition !== 'none' && m.transition !== 'all') {
+            const durMatch = m.transition.match(/([\d.]+)(m?s)\b/);
+            if (durMatch) {
+                durationCount.set(`${durMatch[1]}${durMatch[2]}`, (durationCount.get(`${durMatch[1]}${durMatch[2]}`) ?? 0) + m.count);
+            }
         }
-        return values;
-    });
-    const spacingValues = components.flatMap((component) => [
-        component.styles.padding,
-        component.styles.margin,
-        component.styles.gap,
-        component.styles.rowGap,
-        component.styles.columnGap,
-    ].filter(Boolean));
-    const cssVariableCount = inspirations.reduce((count, inspiration) => (count + Object.keys(inspiration.analysis.cssVariables).length), 0);
-    return {
-        colors: colors.map((color) => color.hex),
-        fontFamilies: unique(typography.map((token) => token.fontFamily.toLowerCase())),
-        fontSizes: unique(typography.map((token) => token.fontSize)),
-        transitions: transitionValues,
-        spacingValues,
-        cssVariableCount,
-        framework: null,
-    };
-}
-function extractFirstJsonObject(raw) {
-    const trimmed = raw.trim();
-    if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
-        return trimmed;
-    }
-    const start = raw.indexOf('{');
-    const end = raw.lastIndexOf('}');
-    if (start >= 0 && end > start) {
-        return raw.slice(start, end + 1);
     }
-    throw new Error('No JSON object found in LLM response');
+    const topEasing = [...easingCount.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 'ease';
+    const durations = [...durationCount.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 4)
+        .map(([d]) => d);
+    const durationMs = durations.map((d) => {
+        const match = d.match(/([\d.]+)(s|ms)/);
+        if (!match)
+            return 300;
+        return match[2] === 's' ? parseFloat(match[1]) * 1000 : parseFloat(match[1]);
+    });
+    // Filter out animation loops (>10s) for intensity classification
+    const uiDurationMs = durationMs.filter((ms) => ms <= 10_000);
+    const avgDuration = uiDurationMs.length > 0
+        ? uiDurationMs.reduce((a, b) => a + b, 0) / uiDurationMs.length
+        : 0;
+    let intensity;
+    if (motion.length <= 3 && avgDuration < 200)
+        intensity = 'subtle';
+    else if (motion.length <= 10 && avgDuration < 400)
+        intensity = 'moderate';
+    else
+        intensity = 'expressive';
+    return { easing: topEasing, durations, intensity };
 }
-async function maybeGenerateNarrative(input) {
-    if (!input.llm) {
-        return {};
+function deriveComponentPreference(components) {
+    const radiusValues = [];
+    const shadowValues = [];
+    for (const comp of components) {
+        const br = comp.styles['border-radius'];
+        if (br && br !== '0px')
+            radiusValues.push(br);
+        const bs = comp.styles['box-shadow'];
+        if (bs && bs !== 'none')
+            shadowValues.push(bs);
+    }
+    const radiusCounts = new Map();
+    for (const r of radiusValues) {
+        radiusCounts.set(r, (radiusCounts.get(r) ?? 0) + 1);
+    }
+    const topRadius = [...radiusCounts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? '0px';
+    let shadowStyle = 'none';
+    if (shadowValues.length > 0) {
+        const hasBigShadow = shadowValues.some((s) => {
+            const nums = s.match(/(\d+)px/g);
+            return nums && nums.some((n) => parseInt(n) > 20);
+        });
+        if (hasBigShadow)
+            shadowStyle = 'dramatic';
+        else if (shadowValues.length > components.length * 0.3)
+            shadowStyle = 'elevated';
+        else
+            shadowStyle = 'subtle';
     }
-    const prompt = [
-        'Return strict JSON with keys: narrative (string), principles (string[]).',
-        'narrative should be 2-3 sentences and concise.',
-        'principles should contain 3-6 short imperative statements.',
-        '',
-        `Persona: ${input.profile.persona.name} — "${input.profile.persona.tagline}"`,
-        `Palette: ${input.profile.color.palette.map((entry) => `${entry.hex} (${entry.role})`).join(', ')}`,
-        `Typography: primary=${input.profile.typography.primaryFont}, secondary=${input.profile.typography.secondaryFont ?? 'none'}`,
-        `Spacing: base=${input.profile.spacing.baseUnit}, scale=${input.profile.spacing.scale.join(', ')}`,
-        `Motion: intensity=${input.profile.motion.intensity}, durations=${input.profile.motion.durations.join(', ')}, easing=${input.profile.motion.easing}`,
-        `Shape: radius=${input.profile.components.borderRadius}, shadow=${input.profile.components.shadowStyle}`,
-    ].join('\n');
-    const content = await runDesignLlm({
-        llm: input.llm,
-        system: 'You are a design systems editor. Output JSON only.',
-        userContent: prompt,
-        temperature: 0.3,
-    });
-    const parsed = JSON.parse(extractFirstJsonObject(content));
     return {
-        narrative: typeof parsed.narrative === 'string' ? parsed.narrative.trim() : undefined,
-        principles: Array.isArray(parsed.principles)
-            ? parsed.principles
-                .map((value) => (typeof value === 'string' ? value.trim() : ''))
-                .filter((value) => value.length > 0)
-                .slice(0, 6)
-            : undefined,
+        cherryPicks: [],
+        borderRadius: topRadius,
+        shadowStyle,
     };
 }
-function mergeConflicts(previous, next) {
-    if (!previous) {
-        return next;
-    }
-    const previousByKey = new Map();
-    for (const conflict of previous.conflicts) {
-        previousByKey.set(`${conflict.dimension}:${conflict.description}`, conflict);
+// ── Conflict detection ─────────────────────────────────────
+function detectConflicts(inspirations) {
+    const conflicts = [];
+    // Font conflict: different primaries across sources
+    const fontsBySource = new Map();
+    for (const ins of inspirations) {
+        const topFont = ins.analysis.typography
+            .sort((a, b) => b.count - a.count)[0]?.fontFamily;
+        if (topFont)
+            fontsBySource.set(ins.name, topFont);
+    }
+    const uniqueFonts = [...new Set(fontsBySource.values())];
+    if (uniqueFonts.length > 2) {
+        conflicts.push({
+            dimension: 'typography',
+            description: `Sources use ${uniqueFonts.length} different primary fonts: ${uniqueFonts.slice(0, 4).join(', ')}`,
+            options: uniqueFonts.slice(0, 4),
+            resolved: false,
+        });
     }
-    return next.map((conflict) => {
-        const prior = previousByKey.get(`${conflict.dimension}:${conflict.description}`);
-        if (!prior) {
-            return conflict;
+    // Color temperature conflict
+    const huesBySource = [];
+    for (const ins of inspirations) {
+        const hues = ins.analysis.colors
+            .filter((c) => c.hex.length === 7)
+            .slice(0, 5)
+            .map((c) => hueFromHex(c.hex));
+        if (hues.length > 0)
+            huesBySource.push(hues);
+    }
+    if (huesBySource.length >= 2) {
+        const avgHues = huesBySource.map((hs) => hs.reduce((a, b) => a + b, 0) / hs.length);
+        const hueSpread = Math.max(...avgHues) - Math.min(...avgHues);
+        if (hueSpread > 120) {
+            conflicts.push({
+                dimension: 'color',
+                description: `Color palettes span ${Math.round(hueSpread)}° of hue — sources have different color temperatures`,
+                options: ['warm bias', 'cool bias', 'mixed palette'],
+                resolved: false,
+            });
         }
-        return {
-            ...conflict,
-            resolved: prior.resolved,
-            resolvedByDecisionId: prior.resolvedByDecisionId,
-        };
-    });
-}
-async function analyzeUrl(options) {
-    if (options.headed) {
-        const result = await theatricalScan(options.url);
-        return result.analysis;
     }
-    const sessionName = `taste-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-    const screenshotPath = path.join(os.tmpdir(), `${sessionName}.png`);
-    return captureDesignFromUrl({
-        url: options.url,
-        sessionName,
-        screenshotPath,
-        workingDir: options.rootDir,
-        journeySteps: 1,
-        responsiveViewports: [{ label: 'desktop', width: 1440, height: 1200 }],
-    });
-}
-function normalizeUrls(urls) {
-    const normalized = urls
-        .map((url) => url.trim())
-        .filter((url) => url.length > 0)
-        .map((url) => {
-        if (!looksLikeUrl(url)) {
-            throw new Error(`Invalid URL/domain input: ${url}`);
-        }
-        return normalizeToUrl(url);
-    });
-    return unique(normalized);
+    return conflicts;
 }
+// ── Main builder ───────────────────────────────────────────
 export async function buildTasteProfile(options) {
-    const urls = normalizeUrls(options.urls);
-    if (urls.length === 0) {
-        throw new Error('At least one URL is required to build a taste profile');
-    }
-    const db = await loadDatabase(options.rootDir);
-    const project = ensureProject(db, {
-        projectId: options.projectId,
-        projectName: options.projectName,
-    });
-    await saveDatabase(options.rootDir, db);
-    const previewAnalyses = [];
-    for (const url of urls) {
-        previewAnalyses.push(await analyzeUrl({
-            rootDir: options.rootDir,
-            url,
-            headed: Boolean(options.headed),
-        }));
-    }
-    for (const url of urls) {
+    const { rootDir, projectId, projectName, urls, headed = false, llm } = options;
+    const db = await loadDatabase(rootDir);
+    const project = ensureProject(db, { projectId, projectName });
+    // Step 1-2: Scan + ingest each URL
+    for (const rawUrl of urls) {
+        const url = looksLikeUrl(rawUrl) ? normalizeToUrl(rawUrl) : rawUrl;
         await ingestInspiration({
-            rootDir: options.rootDir,
+            rootDir,
             project: project.id,
-            projectName: options.projectName,
+            projectName: project.name,
             url,
-            name: url,
-            tags: ['taste'],
+            tags: ['taste-source'],
+            skipVisuals: true,
+            headed,
+            llm,
         });
     }
-    const latestDb = await loadDatabase(options.rootDir);
-    const latestProject = latestDb.projects.find((entry) => entry.id === project.id);
-    if (!latestProject) {
-        throw new Error(`Project not found after ingestion: ${project.id}`);
+    // Step 3: Reload to get all inspirations
+    const freshDb = await loadDatabase(rootDir);
+    const freshProject = freshDb.projects.find((p) => p.id === project.id);
+    if (!freshProject)
+        throw new Error(`Project not found after ingest: ${project.id}`);
+    const inspirations = freshProject.inspirations;
+    if (inspirations.length === 0) {
+        throw new Error('No inspirations found — nothing to build taste from');
     }
-    if (latestProject.inspirations.length === 0) {
-        throw new Error(`No inspirations available for project: ${project.id}`);
-    }
-    const aggregatedColors = aggregateColors(latestProject.inspirations);
-    const aggregatedTypography = aggregateTypography(latestProject.inspirations);
-    const aggregatedComponents = aggregateComponents(latestProject.inspirations);
-    const aggregatedMotion = aggregateMotion(latestProject.inspirations);
-    const color = deriveColorPreference(aggregatedColors, latestProject.inspirations);
-    const typography = deriveTypographyPreference(aggregatedTypography);
-    const spacing = deriveSpacingPreference(aggregatedComponents);
-    const motion = deriveMotionPreference(aggregatedMotion);
-    const components = deriveComponentPreference(aggregatedComponents);
-    const aggregateTokensFromProject = buildAggregateTokens(latestProject.inspirations);
-    const aggregateTokensFromPreview = previewAnalyses
-        .map(designAnalysisToScanTokens)
-        .reduce((acc, tokens) => ({
-        colors: unique([...acc.colors, ...tokens.colors]),
-        fontFamilies: unique([...acc.fontFamilies, ...tokens.fontFamilies]),
-        fontSizes: unique([...acc.fontSizes, ...tokens.fontSizes]),
-        transitions: [...acc.transitions, ...tokens.transitions],
-        spacingValues: [...acc.spacingValues, ...tokens.spacingValues],
-        cssVariableCount: acc.cssVariableCount + tokens.cssVariableCount,
-        framework: null,
-    }), {
-        colors: [],
-        fontFamilies: [],
-        fontSizes: [],
-        transitions: [],
-        spacingValues: [],
-        cssVariableCount: 0,
-        framework: null,
-    });
-    const aggregateTokens = {
-        colors: unique([...aggregateTokensFromProject.colors, ...aggregateTokensFromPreview.colors]),
-        fontFamilies: unique([...aggregateTokensFromProject.fontFamilies, ...aggregateTokensFromPreview.fontFamilies]),
-        fontSizes: unique([...aggregateTokensFromProject.fontSizes, ...aggregateTokensFromPreview.fontSizes]),
-        transitions: [...aggregateTokensFromProject.transitions, ...aggregateTokensFromPreview.transitions],
-        spacingValues: [...aggregateTokensFromProject.spacingValues, ...aggregateTokensFromPreview.spacingValues],
-        cssVariableCount: aggregateTokensFromProject.cssVariableCount + aggregateTokensFromPreview.cssVariableCount,
-        framework: null,
+    // Step 4: Aggregate
+    const colors = aggregateColors(inspirations);
+    const typography = aggregateTypography(inspirations);
+    const components = aggregateComponents(inspirations);
+    const motion = aggregateMotion(inspirations);
+    // Step 5: Derive preferences
+    const colorPref = deriveColorPreference(colors, inspirations);
+    const typographyPref = deriveTypographyPreference(typography);
+    const spacingPref = deriveSpacingPreference(components);
+    const motionPref = deriveMotionPreference(motion);
+    const componentPref = deriveComponentPreference(components);
+    // Step 6: Score + persona
+    const mergedAnalysis = {
+        colors,
+        typography,
+        components: components.map(({ count, ...rest }) => rest),
+        motion: motion.map(({ count, ...rest }) => rest),
+        layout: inspirations.flatMap((i) => i.analysis.layout).slice(0, 50),
+        cssVariables: {},
     };
-    const aggregateScore = computeScore(aggregateTokens);
-    const persona = assignPersona(aggregateTokens);
-    const detectedConflicts = detectConflicts(latestProject.inspirations);
-    const previous = await loadTasteProfile(options.rootDir, project.id);
-    const now = nowIso();
+    const tokens = designAnalysisToScanTokens(mergedAnalysis);
+    const score = computeScore(tokens);
+    const persona = assignPersona(score);
+    // Step 7: Detect conflicts
+    const conflicts = detectConflicts(inspirations);
+    // Step 8: LLM narrative
+    let narrative;
+    let principles;
+    if (llm) {
+        try {
+            const enrichment = await enrichWithLlm({
+                llm,
+                sourceName: `Taste profile for ${project.name}`,
+                analysis: mergedAnalysis,
+            });
+            narrative = enrichment.summary;
+            principles = enrichment.designPrinciples;
+        }
+        catch {
+            // LLM enrichment is optional
+        }
+    }
+    // Step 9: Build + save
+    const existing = await loadTasteProfile(rootDir, project.id);
+    const version = existing ? existing.version + 1 : 1;
     const profile = {
         id: project.id,
-        name: options.projectName?.trim() || latestProject.name,
-        version: (previous?.version ?? 0) + 1,
-        sourceInspirationIds: latestProject.inspirations.map((inspiration) => inspiration.id),
-        sourceUrls: unique(latestProject.inspirations.map((inspiration) => inspiration.url).filter((url) => Boolean(url))),
+        name: project.name,
+        version,
+        sourceInspirationIds: inspirations.map((i) => i.id),
+        sourceUrls: inspirations.filter((i) => i.url).map((i) => i.url),
         persona,
-        aggregateScore,
-        color,
-        typography,
-        spacing,
-        motion,
-        components: {
-            ...components,
-            cherryPicks: previous?.components.cherryPicks ?? [],
-        },
-        decisions: previous?.decisions ?? [],
-        conflicts: mergeConflicts(previous, detectedConflicts),
-        narrative: previous?.narrative,
-        principles: previous?.principles,
-        createdAt: previous?.createdAt ?? now,
-        updatedAt: now,
+        aggregateScore: score,
+        color: colorPref,
+        typography: typographyPref,
+        spacing: spacingPref,
+        motion: motionPref,
+        components: componentPref,
+        decisions: existing?.decisions ?? [],
+        conflicts,
+        narrative,
+        principles,
+        createdAt: existing?.createdAt ?? nowIso(),
+        updatedAt: nowIso(),
     };
-    try {
-        const narrative = await maybeGenerateNarrative({
-            llm: options.llm,
-            profile,
-        });
-        profile.narrative = narrative.narrative ?? profile.narrative;
-        profile.principles = narrative.principles ?? profile.principles;
-    }
-    catch {
-        // LLM enrichment is optional for taste profile building.
-    }
-    await saveTasteProfile(options.rootDir, profile);
+    await saveTasteProfile(rootDir, profile);
+    // Step 10: Return
     return profile;
 }
 //# sourceMappingURL=taste.js.map