Reasoning Rules

return {
    "pattern": rule.get("Recommended_Pattern", ""),
    "style_priority": [s.strip() for s in rule.get("Style_Priority", "").split("+")],
    "color_mood": rule.get("Color_Mood", ""),
    "typography_mood": rule.get("Typography_Mood", ""),
    "key_effects": rule.get("Key_Effects", ""),
    "anti_patterns": rule.get("Anti_Patterns", ""),
    "decision_rules": decision_rules,
    "severity": rule.get("Severity", "MEDIUM")
}

{
  "if_dark_mode": {
    "color_strategy": "High contrast with OLED-friendly blacks",
    "avoid": "Pure white text (use #E4E4E7)"
  },
  "if_b2b": {
    "pattern": "Trust & Authority",
    "key_effects": "Minimal, professional"
  }
}

# Parse decision rules JSON
decision_rules = {}
try:
    decision_rules = json.loads(rule.get("Decision_Rules", "{}"))
except json.JSONDecodeError:
    pass

def _find_reasoning_rule(self, category: str) -> dict:
    """Find matching reasoning rule for a category."""
    category_lower = category.lower()

    # Try exact match first
    for rule in self.reasoning_data:
        if rule.get("UI_Category", "").lower() == category_lower:
            return rule

    # Try partial match
    for rule in self.reasoning_data:
        ui_cat = rule.get("UI_Category", "").lower()
        if ui_cat in category_lower or category_lower in ui_cat:
            return rule

    # Try keyword match
    for rule in self.reasoning_data:
        ui_cat = rule.get("UI_Category", "").lower()
        keywords = ui_cat.replace("/", " ").replace("-", " ").split()
        if any(kw in category_lower for kw in keywords):
            return rule

    return {}

# Step 2: Get reasoning rules for this category
reasoning = self._apply_reasoning(category, {})
style_priority = reasoning.get("style_priority", [])

def _multi_domain_search(self, query: str, style_priority: list = None) -> dict:
    """Execute searches across multiple domains."""
    results = {}
    for domain, config in SEARCH_CONFIG.items():
        if domain == "style" and style_priority:
            # For style, also search with priority keywords
            priority_query = " ".join(style_priority[:2]) if style_priority else query
            combined_query = f"{query} {priority_query}"
            results[domain] = search(combined_query, domain, config["max_results"])
        else:
            results[domain] = search(query, domain, config["max_results"])
    return results

def _select_best_match(self, results: list, priority_keywords: list) -> dict:
    """Select best matching result based on priority keywords."""
    if not results:
        return {}

    if not priority_keywords:
        return results[0]

    # First: try exact style name match
    for priority in priority_keywords:
        priority_lower = priority.lower().strip()
        for result in results:
            style_name = result.get("Style Category", "").lower()
            if priority_lower in style_name or style_name in priority_lower:
                return result

    # Second: score by keyword match in all fields
    scored = []
    for result in results:
        result_str = str(result).lower()
        score = 0
        for kw in priority_keywords:
            kw_lower = kw.lower().strip()
            # Higher score for style name match
            if kw_lower in result.get("Style Category", "").lower():
                score += 10
            # Lower score for keyword field match
            elif kw_lower in result.get("Keywords", "").lower():
                score += 3
            # Even lower for other field matches
            elif kw_lower in result_str:
                score += 1
        scored.append((score, result))

    scored.sort(key=lambda x: x[0], reverse=True)
    return scored[0][1] if scored and scored[0][0] > 0 else results[0]

python3 .claude/skills/ui-ux-pro-max/scripts/search.py "beauty spa wellness service" --design-system -p "Serenity Spa"

+----------------------------------------------------------------------------------------+
|  PATTERN: Hero-Centric + Social Proof                                                  |
|  STYLE: Soft UI Evolution                                                              |
|  COLORS: #E8B4B8 (Soft Pink) + #A8D5BA (Sage Green)                                    |
|  TYPOGRAPHY: Cormorant Garamond / Montserrat                                           |
|  KEY EFFECTS: Soft shadows + Smooth transitions (200-300ms)                            |
|  AVOID: Bright neon colors + Harsh animations + Dark mode                              |
+----------------------------------------------------------------------------------------+

if not rule:
    return {
        "pattern": "Hero + Features + CTA",
        "style_priority": ["Minimalism", "Flat Design"],
        "color_mood": "Professional",
        "typography_mood": "Clean",
        "key_effects": "Subtle hover transitions",
        "anti_patterns": "",
        "decision_rules": {},
        "severity": "MEDIUM"
    }

python3 .claude/skills/ui-ux-pro-max/scripts/search.py "<your product type>" --design-system