Upload normalizer.py

agents/normalizer.py

@@ -0,0 +1,497 @@
+"""
+Agent 2: Token Normalizer & Structurer
+Design System Extractor v2
+
+Persona: Design System Librarian
+
+Responsibilities:
+- Clean noisy extraction data
+- Deduplicate similar tokens (colors within threshold, similar spacing)
+- Infer naming patterns from class names and contexts
+- Tag tokens as: detected | inferred | low-confidence
+- Group colors by role (primary, secondary, neutral, etc.)
+"""
+
+import re
+from typing import Optional
+from collections import defaultdict
+
+from core.token_schema import (
+    ColorToken,
+    TypographyToken,
+    SpacingToken,
+    ExtractedTokens,
+    NormalizedTokens,
+    Confidence,
+    TokenSource,
+)
+from core.color_utils import (
+    parse_color,
+    normalize_hex,
+    categorize_color,
+)
+
+
+class TokenNormalizer:
+    """
+    Normalizes and structures extracted tokens.
+    
+    This is Agent 2's job — taking raw extraction data and
+    organizing it into a clean, deduplicated structure.
+    """
+    
+    def __init__(self):
+        # Thresholds for duplicate detection
+        self.color_similarity_threshold = 10  # Delta in RGB space
+        self.spacing_merge_threshold = 2  # px difference to merge
+        
+        # Naming patterns
+        self.color_role_keywords = {
+            "primary": ["primary", "brand", "main", "accent"],
+            "secondary": ["secondary", "alt", "alternate"],
+            "success": ["success", "green", "positive", "valid"],
+            "warning": ["warning", "yellow", "caution", "alert"],
+            "error": ["error", "red", "danger", "invalid", "negative"],
+            "info": ["info", "blue", "notice"],
+            "neutral": ["gray", "grey", "neutral", "muted", "subtle"],
+            "background": ["bg", "background", "surface"],
+            "text": ["text", "foreground", "content", "body"],
+            "border": ["border", "divider", "separator", "line"],
+        }
+    
+    def normalize(self, extracted: ExtractedTokens) -> NormalizedTokens:
+        """
+        Normalize extracted tokens.
+        
+        Args:
+            extracted: Raw extraction results from Agent 1
+            
+        Returns:
+            NormalizedTokens with cleaned, deduplicated data
+        """
+        # Process each token type (returns lists)
+        colors_list = self._normalize_colors(extracted.colors)
+        typography_list = self._normalize_typography(extracted.typography)
+        spacing_list = self._normalize_spacing(extracted.spacing)
+        
+        # Convert to dicts keyed by suggested_name
+        colors_dict = {}
+        for c in colors_list:
+            key = c.suggested_name or c.value
+            colors_dict[key] = c
+        
+        typography_dict = {}
+        for t in typography_list:
+            key = t.suggested_name or f"{t.font_family}-{t.font_size}"
+            typography_dict[key] = t
+        
+        spacing_dict = {}
+        for s in spacing_list:
+            key = s.suggested_name or s.value
+            spacing_dict[key] = s
+        
+        # Convert radius and shadows to dicts
+        radius_dict = {}
+        for r in extracted.radius:
+            key = f"radius-{r.value}"
+            radius_dict[key] = r
+        
+        shadows_dict = {}
+        for s in extracted.shadows:
+            key = f"shadow-{hash(s.value) % 1000}"
+            shadows_dict[key] = s
+        
+        # Create normalized result
+        normalized = NormalizedTokens(
+            viewport=extracted.viewport,
+            source_url=extracted.source_url,
+            colors=colors_dict,
+            typography=typography_dict,
+            spacing=spacing_dict,
+            radius=radius_dict,
+            shadows=shadows_dict,
+            font_families=extracted.font_families,
+            detected_spacing_base=extracted.spacing_base,
+            detected_naming_convention=extracted.naming_convention,
+        )
+        
+        return normalized
+    
+    def _normalize_colors(self, colors: list[ColorToken]) -> list[ColorToken]:
+        """
+        Normalize color tokens:
+        - Deduplicate similar colors
+        - Infer color roles
+        - Assign suggested names
+        - Calculate confidence
+        """
+        if not colors:
+            return []
+        
+        # Step 1: Deduplicate by exact hex value
+        unique_colors = {}
+        for color in colors:
+            hex_val = normalize_hex(color.value)
+            if hex_val in unique_colors:
+                # Merge frequency and contexts
+                existing = unique_colors[hex_val]
+                existing.frequency += color.frequency
+                existing.contexts = list(set(existing.contexts + color.contexts))
+                existing.elements = list(set(existing.elements + color.elements))
+                existing.css_properties = list(set(existing.css_properties + color.css_properties))
+            else:
+                color.value = hex_val
+                unique_colors[hex_val] = color
+        
+        # Step 2: Merge visually similar colors
+        merged_colors = self._merge_similar_colors(list(unique_colors.values()))
+        
+        # Step 3: Infer roles and names
+        for color in merged_colors:
+            role = self._infer_color_role(color)
+            if role:
+                color.suggested_name = self._generate_color_name(color, role)
+            else:
+                color.suggested_name = self._generate_color_name_from_value(color)
+            
+            # Update confidence based on frequency
+            color.confidence = self._calculate_confidence(color.frequency)
+        
+        # Sort by frequency (most used first)
+        merged_colors.sort(key=lambda c: -c.frequency)
+        
+        return merged_colors
+    
+    def _merge_similar_colors(self, colors: list[ColorToken]) -> list[ColorToken]:
+        """Merge colors that are visually very similar."""
+        if len(colors) <= 1:
+            return colors
+        
+        merged = []
+        used = set()
+        
+        for i, color1 in enumerate(colors):
+            if i in used:
+                continue
+            
+            # Find similar colors
+            similar_group = [color1]
+            for j, color2 in enumerate(colors[i+1:], i+1):
+                if j in used:
+                    continue
+                if self._colors_are_similar(color1.value, color2.value):
+                    similar_group.append(color2)
+                    used.add(j)
+            
+            # Merge the group - keep the most frequent
+            similar_group.sort(key=lambda c: -c.frequency)
+            primary = similar_group[0]
+            
+            # Aggregate data from similar colors
+            for other in similar_group[1:]:
+                primary.frequency += other.frequency
+                primary.contexts = list(set(primary.contexts + other.contexts))
+                primary.elements = list(set(primary.elements + other.elements))
+            
+            merged.append(primary)
+            used.add(i)
+        
+        return merged
+    
+    def _colors_are_similar(self, hex1: str, hex2: str) -> bool:
+        """Check if two colors are visually similar."""
+        try:
+            parsed1 = parse_color(hex1)
+            parsed2 = parse_color(hex2)
+            if parsed1 is None or parsed2 is None:
+                return False
+            if parsed1.rgb is None or parsed2.rgb is None:
+                return False
+            
+            rgb1 = parsed1.rgb
+            rgb2 = parsed2.rgb
+            
+            # Calculate Euclidean distance in RGB space
+            distance = sum((a - b) ** 2 for a, b in zip(rgb1, rgb2)) ** 0.5
+            return distance < self.color_similarity_threshold
+        except Exception:
+            return False
+    
+    def _infer_color_role(self, color: ColorToken) -> Optional[str]:
+        """Infer the semantic role of a color from its contexts."""
+        all_context = " ".join(color.contexts + color.elements).lower()
+        
+        for role, keywords in self.color_role_keywords.items():
+            for keyword in keywords:
+                if keyword in all_context:
+                    return role
+        
+        # Try to infer from color category
+        category = categorize_color(color.value)
+        if category in ["gray", "white", "black"]:
+            return "neutral"
+        
+        return None
+    
+    def _generate_color_name(self, color: ColorToken, role: str) -> str:
+        """Generate a semantic name for a color."""
+        # Determine shade level based on luminance
+        parsed = parse_color(color.value)
+        if parsed and parsed.rgb:
+            rgb = parsed.rgb
+            luminance = (0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]) / 255
+            if luminance > 0.8:
+                shade = "50"
+            elif luminance > 0.6:
+                shade = "200"
+            elif luminance > 0.4:
+                shade = "500"
+            elif luminance > 0.2:
+                shade = "700"
+            else:
+                shade = "900"
+        else:
+            shade = "500"
+        
+        return f"color.{role}.{shade}"
+    
+    def _generate_color_name_from_value(self, color: ColorToken) -> str:
+        """Generate a name based on the color value itself."""
+        category = categorize_color(color.value)
+        parsed = parse_color(color.value)
+        
+        if parsed and parsed.rgb:
+            rgb = parsed.rgb
+            luminance = (0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]) / 255
+            if luminance > 0.6:
+                shade = "light"
+            elif luminance > 0.3:
+                shade = "base"
+            else:
+                shade = "dark"
+        else:
+            shade = "base"
+        
+        return f"color.{category}.{shade}"
+    
+    def _normalize_typography(self, typography: list[TypographyToken]) -> list[TypographyToken]:
+        """
+        Normalize typography tokens:
+        - Deduplicate identical styles
+        - Infer type scale categories
+        - Assign suggested names
+        """
+        if not typography:
+            return []
+        
+        # Deduplicate by unique style combination
+        unique_typo = {}
+        for typo in typography:
+            key = f"{typo.font_family}|{typo.font_size}|{typo.font_weight}|{typo.line_height}"
+            if key in unique_typo:
+                existing = unique_typo[key]
+                existing.frequency += typo.frequency
+                existing.elements = list(set(existing.elements + typo.elements))
+            else:
+                unique_typo[key] = typo
+        
+        result = list(unique_typo.values())
+        
+        # Infer names based on size and elements
+        for typo in result:
+            typo.suggested_name = self._generate_typography_name(typo)
+            typo.confidence = self._calculate_confidence(typo.frequency)
+        
+        # Sort by font size (largest first)
+        result.sort(key=lambda t: -self._parse_font_size(t.font_size))
+        
+        return result
+    
+    def _generate_typography_name(self, typo: TypographyToken) -> str:
+        """Generate a semantic name for typography."""
+        size_px = self._parse_font_size(typo.font_size)
+        elements = " ".join(typo.elements).lower()
+        
+        # Determine category from elements
+        if any(h in elements for h in ["h1", "hero", "display"]):
+            category = "display"
+        elif any(h in elements for h in ["h2", "h3", "h4", "h5", "h6", "heading", "title"]):
+            category = "heading"
+        elif any(h in elements for h in ["label", "caption", "small", "meta"]):
+            category = "label"
+        elif any(h in elements for h in ["body", "p", "paragraph", "text"]):
+            category = "body"
+        else:
+            category = "text"
+        
+        # Determine size tier
+        if size_px >= 32:
+            size_tier = "xl"
+        elif size_px >= 24:
+            size_tier = "lg"
+        elif size_px >= 18:
+            size_tier = "md"
+        elif size_px >= 14:
+            size_tier = "sm"
+        else:
+            size_tier = "xs"
+        
+        return f"font.{category}.{size_tier}"
+    
+    def _parse_font_size(self, size: str) -> float:
+        """Parse font size string to pixels."""
+        if not size:
+            return 16
+        
+        size = size.lower().strip()
+        
+        # Handle px
+        if "px" in size:
+            try:
+                return float(size.replace("px", ""))
+            except ValueError:
+                return 16
+        
+        # Handle rem (assume 16px base)
+        if "rem" in size:
+            try:
+                return float(size.replace("rem", "")) * 16
+            except ValueError:
+                return 16
+        
+        # Handle em (assume 16px base)
+        if "em" in size:
+            try:
+                return float(size.replace("em", "")) * 16
+            except ValueError:
+                return 16
+        
+        # Try plain number
+        try:
+            return float(size)
+        except ValueError:
+            return 16
+    
+    def _normalize_spacing(self, spacing: list[SpacingToken]) -> list[SpacingToken]:
+        """
+        Normalize spacing tokens:
+        - Merge similar values
+        - Align to base-8 grid if close
+        - Assign suggested names
+        """
+        if not spacing:
+            return []
+        
+        # Deduplicate by value
+        unique_spacing = {}
+        for space in spacing:
+            key = space.value
+            if key in unique_spacing:
+                existing = unique_spacing[key]
+                existing.frequency += space.frequency
+                existing.contexts = list(set(existing.contexts + space.contexts))
+            else:
+                unique_spacing[key] = space
+        
+        result = list(unique_spacing.values())
+        
+        # Merge very similar values
+        result = self._merge_similar_spacing(result)
+        
+        # Assign names
+        for space in result:
+            space.suggested_name = self._generate_spacing_name(space)
+            space.confidence = self._calculate_confidence(space.frequency)
+        
+        # Sort by value
+        result.sort(key=lambda s: s.value_px)
+        
+        return result
+    
+    def _merge_similar_spacing(self, spacing: list[SpacingToken]) -> list[SpacingToken]:
+        """Merge spacing values that are very close."""
+        if len(spacing) <= 1:
+            return spacing
+        
+        # Sort by pixel value
+        spacing.sort(key=lambda s: s.value_px)
+        
+        merged = []
+        i = 0
+        
+        while i < len(spacing):
+            current = spacing[i]
+            group = [current]
+            
+            # Find adjacent similar values
+            j = i + 1
+            while j < len(spacing):
+                if abs(spacing[j].value_px - current.value_px) <= self.spacing_merge_threshold:
+                    group.append(spacing[j])
+                    j += 1
+                else:
+                    break
+            
+            # Merge group - prefer base-8 aligned value or most frequent
+            group.sort(key=lambda s: (-s.fits_base_8, -s.frequency))
+            primary = group[0]
+            
+            for other in group[1:]:
+                primary.frequency += other.frequency
+                primary.contexts = list(set(primary.contexts + other.contexts))
+            
+            merged.append(primary)
+            i = j
+        
+        return merged
+    
+    def _generate_spacing_name(self, space: SpacingToken) -> str:
+        """Generate a semantic name for spacing."""
+        px = space.value_px
+        
+        # Map to t-shirt sizes based on value
+        if px <= 2:
+            size = "px"
+        elif px <= 4:
+            size = "0.5"
+        elif px <= 8:
+            size = "1"
+        elif px <= 12:
+            size = "1.5"
+        elif px <= 16:
+            size = "2"
+        elif px <= 20:
+            size = "2.5"
+        elif px <= 24:
+            size = "3"
+        elif px <= 32:
+            size = "4"
+        elif px <= 40:
+            size = "5"
+        elif px <= 48:
+            size = "6"
+        elif px <= 64:
+            size = "8"
+        elif px <= 80:
+            size = "10"
+        elif px <= 96:
+            size = "12"
+        else:
+            size = str(int(px / 4))
+        
+        return f"space.{size}"
+    
+    def _calculate_confidence(self, frequency: int) -> Confidence:
+        """Calculate confidence based on frequency."""
+        if frequency >= 10:
+            return Confidence.HIGH
+        elif frequency >= 3:
+            return Confidence.MEDIUM
+        else:
+            return Confidence.LOW
+
+
+def normalize_tokens(extracted: ExtractedTokens) -> NormalizedTokens:
+    """Convenience function to normalize tokens."""
+    normalizer = TokenNormalizer()
+    return normalizer.normalize(extracted)