Upload rule_engine.py

core/rule_engine.py

@@ -40,6 +40,7 @@ class TypeScaleAnalysis:
     ratios_between_sizes: list[float]
     recommendation: float
     recommendation_name: str
+    base_size: float = 16.0  # Detected base/body font size
     
     def to_dict(self) -> dict:
         return {
@@ -49,6 +50,7 @@ class TypeScaleAnalysis:
             "is_consistent": self.is_consistent,
             "variance": round(self.variance, 3),
             "sizes_px": self.sizes_px,
+            "base_size": self.base_size,
             "recommendation": self.recommendation,
             "recommendation_name": self.recommendation_name,
         }
@@ -381,6 +383,7 @@ def analyze_type_scale(typography_tokens: dict) -> TypeScaleAnalysis:
     sizes_px = sorted(set(sizes))
     
     if len(sizes_px) < 2:
+        base_size = sizes_px[0] if sizes_px else 16.0
         return TypeScaleAnalysis(
             detected_ratio=1.0,
             closest_standard_ratio=1.25,
@@ -391,6 +394,7 @@ def analyze_type_scale(typography_tokens: dict) -> TypeScaleAnalysis:
             ratios_between_sizes=[],
             recommendation=1.25,
             recommendation_name="Major Third",
+            base_size=base_size,
         )
     
     # Calculate ratios between consecutive sizes
@@ -402,6 +406,9 @@ def analyze_type_scale(typography_tokens: dict) -> TypeScaleAnalysis:
                 ratios.append(ratio)
     
     if not ratios:
+        # Detect base size even if no valid ratios
+        base_candidates = [s for s in sizes_px if 14 <= s <= 18]
+        base_size = min(base_candidates, key=lambda x: abs(x - 16)) if base_candidates else (min(sizes_px, key=lambda x: abs(x - 16)) if sizes_px else 16.0)
         return TypeScaleAnalysis(
             detected_ratio=1.0,
             closest_standard_ratio=1.25,
@@ -412,6 +419,7 @@ def analyze_type_scale(typography_tokens: dict) -> TypeScaleAnalysis:
             ratios_between_sizes=[],
             recommendation=1.25,
             recommendation_name="Major Third",
+            base_size=base_size,
         )
     
     # Average ratio
@@ -425,6 +433,21 @@ def analyze_type_scale(typography_tokens: dict) -> TypeScaleAnalysis:
     closest_scale = min(STANDARD_SCALES.keys(), key=lambda x: abs(x - avg_ratio))
     scale_name = STANDARD_SCALES[closest_scale]
     
+    # Detect base size (closest to 16px, or 14-18px range typical for body)
+    # The base size is typically the most common body text size
+    base_candidates = [s for s in sizes_px if 14 <= s <= 18]
+    if base_candidates:
+        # Prefer 16px if present, otherwise closest to 16
+        if 16 in base_candidates:
+            base_size = 16.0
+        else:
+            base_size = min(base_candidates, key=lambda x: abs(x - 16))
+    elif sizes_px:
+        # Fallback: find size closest to 16px
+        base_size = min(sizes_px, key=lambda x: abs(x - 16))
+    else:
+        base_size = 16.0
+    
     # Recommendation
     if is_consistent and abs(avg_ratio - closest_scale) < 0.05:
         # Already using a standard scale
@@ -445,6 +468,7 @@ def analyze_type_scale(typography_tokens: dict) -> TypeScaleAnalysis:
         ratios_between_sizes=ratios,
         recommendation=recommendation,
         recommendation_name=recommendation_name,
+        base_size=base_size,
     )
 
 
@@ -452,45 +476,48 @@ def analyze_type_scale(typography_tokens: dict) -> TypeScaleAnalysis:
 # ACCESSIBILITY ANALYSIS
 # =============================================================================
 
-def analyze_accessibility(color_tokens: dict) -> list[ColorAccessibility]:
+def analyze_accessibility(color_tokens: dict, fg_bg_pairs: list[dict] = None) -> list[ColorAccessibility]:
     """
     Analyze all colors for WCAG accessibility compliance.
-    
+
     Args:
         color_tokens: Dict of color tokens with value/hex
-        
+        fg_bg_pairs: Optional list of actual foreground/background pairs
+                     extracted from the DOM (each dict has 'foreground',
+                     'background', 'element' keys).
+
     Returns:
         List of ColorAccessibility results
     """
     results = []
-    
+
     for name, token in color_tokens.items():
         if isinstance(token, dict):
             hex_color = token.get("value") or token.get("hex") or token.get("color")
         else:
             hex_color = getattr(token, "value", None)
-        
+
         if not hex_color or not hex_color.startswith("#"):
             continue
-        
+
         try:
             contrast_white = get_contrast_ratio(hex_color, "#ffffff")
             contrast_black = get_contrast_ratio(hex_color, "#000000")
-            
+
             passes_aa_normal = contrast_white >= 4.5 or contrast_black >= 4.5
             passes_aa_large = contrast_white >= 3.0 or contrast_black >= 3.0
             passes_aaa_normal = contrast_white >= 7.0 or contrast_black >= 7.0
-            
+
             best_text = "#ffffff" if contrast_white > contrast_black else "#000000"
-            
+
             # Generate fix suggestion if needed
             suggested_fix = None
             suggested_fix_contrast = None
-            
+
             if not passes_aa_normal:
                 suggested_fix = find_aa_compliant_color(hex_color, "#ffffff", 4.5)
                 suggested_fix_contrast = get_contrast_ratio(suggested_fix, "#ffffff")
-            
+
             results.append(ColorAccessibility(
                 hex_color=hex_color,
                 name=name,
@@ -505,7 +532,36 @@ def analyze_accessibility(color_tokens: dict) -> list[ColorAccessibility]:
             ))
         except Exception:
             continue
-    
+
+    # --- Real foreground-background pair checks ---
+    if fg_bg_pairs:
+        for pair in fg_bg_pairs:
+            fg = pair.get("foreground", "")
+            bg = pair.get("background", "")
+            element = pair.get("element", "")
+            if not (fg.startswith("#") and bg.startswith("#")):
+                continue
+            try:
+                ratio = get_contrast_ratio(fg, bg)
+                if ratio < 4.5:
+                    # This pair fails AA — record it
+                    fix = find_aa_compliant_color(fg, bg, 4.5)
+                    fix_contrast = get_contrast_ratio(fix, bg)
+                    results.append(ColorAccessibility(
+                        hex_color=fg,
+                        name=f"fg:{fg} on bg:{bg} ({element})",
+                        contrast_on_white=get_contrast_ratio(fg, "#ffffff"),
+                        contrast_on_black=get_contrast_ratio(fg, "#000000"),
+                        passes_aa_normal=False,
+                        passes_aa_large=ratio >= 3.0,
+                        passes_aaa_normal=False,
+                        best_text_color="#ffffff" if get_contrast_ratio(fg, "#ffffff") > get_contrast_ratio(fg, "#000000") else "#000000",
+                        suggested_fix=fix,
+                        suggested_fix_contrast=fix_contrast,
+                    ))
+            except Exception:
+                continue
+
     return results
 
 
@@ -668,6 +724,7 @@ def run_rule_engine(
     radius_tokens: dict = None,
     shadow_tokens: dict = None,
     log_callback: Optional[callable] = None,
+    fg_bg_pairs: list[dict] = None,
 ) -> RuleEngineResults:
     """
     Run complete rule-based analysis on design tokens.
@@ -716,23 +773,38 @@ def run_rule_engine(
     # ─────────────────────────────────────────────────────────────
     log("   ♿ ACCESSIBILITY CHECK (WCAG AA/AAA)")
     log("   " + "─" * 40)
-    accessibility = analyze_accessibility(color_tokens)
+    accessibility = analyze_accessibility(color_tokens, fg_bg_pairs=fg_bg_pairs)
     
+    # Separate individual-color failures from real FG/BG pair failures
+    pair_failures = [a for a in accessibility if not a.passes_aa_normal and a.name.startswith("fg:")]
+    color_only_failures = [a for a in accessibility if not a.passes_aa_normal and not a.name.startswith("fg:")]
     failures = [a for a in accessibility if not a.passes_aa_normal]
     passes = len(accessibility) - len(failures)
-    
+
+    pair_count = len(fg_bg_pairs) if fg_bg_pairs else 0
     log(f"   ├─ Colors Analyzed: {len(accessibility)}")
+    log(f"   ├─ FG/BG Pairs Checked: {pair_count}")
     log(f"   ├─ AA Pass: {passes} ✅")
-    log(f"   ├─ AA Fail: {len(failures)} {'❌' if failures else '✅'}")
-    
-    if failures:
+    log(f"   ├─ AA Fail (color vs white/black): {len(color_only_failures)} {'❌' if color_only_failures else '✅'}")
+    log(f"   ├─ AA Fail (real FG/BG pairs): {len(pair_failures)} {'❌' if pair_failures else '✅'}")
+
+    if color_only_failures:
         log("   │")
-        log("   │  ⚠️  FAILING COLORS:")
-        for i, f in enumerate(failures[:5]):
+        log("   │  ⚠️  FAILING COLORS (vs white/black):")
+        for i, f in enumerate(color_only_failures[:5]):
             fix_info = f" → 💡 Fix: {f.suggested_fix} ({f.suggested_fix_contrast:.1f}:1)" if f.suggested_fix else ""
             log(f"   │  ├─ {f.name}: {f.hex_color} ({f.contrast_on_white:.1f}:1 on white){fix_info}")
-        if len(failures) > 5:
-            log(f"   │  └─ ... and {len(failures) - 5} more")
+        if len(color_only_failures) > 5:
+            log(f"   │  └─ ... and {len(color_only_failures) - 5} more")
+
+    if pair_failures:
+        log("   │")
+        log("   │  ❌ FAILING FG/BG PAIRS (actual on-page combinations):")
+        for i, f in enumerate(pair_failures[:5]):
+            fix_info = f" → 💡 Fix: {f.suggested_fix} ({f.suggested_fix_contrast:.1f}:1)" if f.suggested_fix else ""
+            log(f"   │  ├─ {f.name}{fix_info}")
+        if len(pair_failures) > 5:
+            log(f"   │  └─ ... and {len(pair_failures) - 5} more")
     
     log("")