1#!/usr/bin/env python3
2# -*- coding: utf-8 -*-
3"""
4Design System Generator - Aggregates search results and applies reasoning
5to generate comprehensive design system recommendations.
6 
7Usage:
8    from design_system import generate_design_system
9    result = generate_design_system("SaaS dashboard", "My Project")
10    
11    # With persistence (Master + Overrides pattern)
12    result = generate_design_system("SaaS dashboard", "My Project", persist=True)
13    result = generate_design_system("SaaS dashboard", "My Project", persist=True, page="dashboard")
14"""
15 
16import csv
17import json
18import os
19from datetime import datetime
20from pathlib import Path
21from core import search, DATA_DIR
22 
23 
24# ============ CONFIGURATION ============
25REASONING_FILE = "ui-reasoning.csv"
26 
27SEARCH_CONFIG = {
28    "product": {"max_results": 1},
29    "style": {"max_results": 3},
30    "color": {"max_results": 2},
31    "landing": {"max_results": 2},
32    "typography": {"max_results": 2}
33}
34 
35 
36# ============ DESIGN SYSTEM GENERATOR ============
37class DesignSystemGenerator:
38    """Generates design system recommendations from aggregated searches."""
39 
40    def __init__(self):
41        self.reasoning_data = self._load_reasoning()
42 
43    def _load_reasoning(self) -> list:
44        """Load reasoning rules from CSV."""
45        filepath = DATA_DIR / REASONING_FILE
46        if not filepath.exists():
47            return []
48        with open(filepath, 'r', encoding='utf-8') as f:
49            return list(csv.DictReader(f))
50 
51    def _multi_domain_search(self, query: str, style_priority: list = None) -> dict:
52        """Execute searches across multiple domains."""
53        results = {}
54        for domain, config in SEARCH_CONFIG.items():
55            if domain == "style" and style_priority:
56                # For style, also search with priority keywords
57                priority_query = " ".join(style_priority[:2]) if style_priority else query
58                combined_query = f"{query} {priority_query}"
59                results[domain] = search(combined_query, domain, config["max_results"])
60            else:
61                results[domain] = search(query, domain, config["max_results"])
62        return results
63 
64    def _find_reasoning_rule(self, category: str) -> dict:
65        """Find matching reasoning rule for a category."""
66        category_lower = category.lower()
67 
68        # Try exact match first
69        for rule in self.reasoning_data:
70            if rule.get("UI_Category", "").lower() == category_lower:
71                return rule
72 
73        # Try partial match
74        for rule in self.reasoning_data:
75            ui_cat = rule.get("UI_Category", "").lower()
76            if ui_cat in category_lower or category_lower in ui_cat:
77                return rule
78 
79        # Try keyword match
80        for rule in self.reasoning_data:
81            ui_cat = rule.get("UI_Category", "").lower()
82            keywords = ui_cat.replace("/", " ").replace("-", " ").split()
83            if any(kw in category_lower for kw in keywords):
84                return rule
85 
86        return {}
87 
88    def _apply_reasoning(self, category: str, search_results: dict) -> dict:
89        """Apply reasoning rules to search results."""
90        rule = self._find_reasoning_rule(category)
91 
92        if not rule:
93            return {
94                "pattern": "Hero + Features + CTA",
95                "style_priority": ["Minimalism", "Flat Design"],
96                "color_mood": "Professional",
97                "typography_mood": "Clean",
98                "key_effects": "Subtle hover transitions",
99                "anti_patterns": "",
100                "decision_rules": {},
101                "severity": "MEDIUM"
102            }
103 
104        # Parse decision rules JSON
105        decision_rules = {}
106        try:
107            decision_rules = json.loads(rule.get("Decision_Rules", "{}"))
108        except json.JSONDecodeError:
109            pass
110 
111        return {
112            "pattern": rule.get("Recommended_Pattern", ""),
113            "style_priority": [s.strip() for s in rule.get("Style_Priority", "").split("+")],
114            "color_mood": rule.get("Color_Mood", ""),
115            "typography_mood": rule.get("Typography_Mood", ""),
116            "key_effects": rule.get("Key_Effects", ""),
117            "anti_patterns": rule.get("Anti_Patterns", ""),
118            "decision_rules": decision_rules,
119            "severity": rule.get("Severity", "MEDIUM")
120        }
121 
122    def _select_best_match(self, results: list, priority_keywords: list) -> dict:
123        """Select best matching result based on priority keywords."""
124        if not results:
125            return {}
126 
127        if not priority_keywords:
128            return results[0]
129 
130        # First: try exact style name match
131        for priority in priority_keywords:
132            priority_lower = priority.lower().strip()
133            for result in results:
134                style_name = result.get("Style Category", "").lower()
135                if priority_lower in style_name or style_name in priority_lower:
136                    return result
137 
138        # Second: score by keyword match in all fields
139        scored = []
140        for result in results:
141            result_str = str(result).lower()
142            score = 0
143            for kw in priority_keywords:
144                kw_lower = kw.lower().strip()
145                # Higher score for style name match
146                if kw_lower in result.get("Style Category", "").lower():
147                    score += 10
148                # Lower score for keyword field match
149                elif kw_lower in result.get("Keywords", "").lower():
150                    score += 3
151                # Even lower for other field matches
152                elif kw_lower in result_str:
153                    score += 1
154            scored.append((score, result))
155 
156        scored.sort(key=lambda x: x[0], reverse=True)
157        return scored[0][1] if scored and scored[0][0] > 0 else results[0]
158 
159    def _extract_results(self, search_result: dict) -> list:
160        """Extract results list from search result dict."""
161        return search_result.get("results", [])
162 
163    def generate(self, query: str, project_name: str = None) -> dict:
164        """Generate complete design system recommendation."""
165        # Step 1: First search product to get category
166        product_result = search(query, "product", 1)
167        product_results = product_result.get("results", [])
168        category = "General"
169        if product_results:
170            category = product_results[0].get("Product Type", "General")
171 
172        # Step 2: Get reasoning rules for this category
173        reasoning = self._apply_reasoning(category, {})
174        style_priority = reasoning.get("style_priority", [])
175 
176        # Step 3: Multi-domain search with style priority hints
177        search_results = self._multi_domain_search(query, style_priority)
178        search_results["product"] = product_result  # Reuse product search
179 
180        # Step 4: Select best matches from each domain using priority
181        style_results = self._extract_results(search_results.get("style", {}))
182        color_results = self._extract_results(search_results.get("color", {}))
183        typography_results = self._extract_results(search_results.get("typography", {}))
184        landing_results = self._extract_results(search_results.get("landing", {}))
185 
186        best_style = self._select_best_match(style_results, reasoning.get("style_priority", []))
187        best_color = color_results[0] if color_results else {}
188        best_typography = typography_results[0] if typography_results else {}
189        best_landing = landing_results[0] if landing_results else {}
190 
191        # Step 5: Build final recommendation
192        # Combine effects from both reasoning and style search
193        style_effects = best_style.get("Effects & Animation", "")
194        reasoning_effects = reasoning.get("key_effects", "")
195        combined_effects = style_effects if style_effects else reasoning_effects
196 
197        return {
198            "project_name": project_name or query.upper(),
199            "category": category,
200            "pattern": {
201                "name": best_landing.get("Pattern Name", reasoning.get("pattern", "Hero + Features + CTA")),
202                "sections": best_landing.get("Section Order", "Hero > Features > CTA"),
203                "cta_placement": best_landing.get("Primary CTA Placement", "Above fold"),
204                "color_strategy": best_landing.get("Color Strategy", ""),
205                "conversion": best_landing.get("Conversion Optimization", "")
206            },
207            "style": {
208                "name": best_style.get("Style Category", "Minimalism"),
209                "type": best_style.get("Type", "General"),
210                "effects": style_effects,
211                "keywords": best_style.get("Keywords", ""),
212                "best_for": best_style.get("Best For", ""),
213                "performance": best_style.get("Performance", ""),
214                "accessibility": best_style.get("Accessibility", "")
215            },
216            "colors": {
217                "primary": best_color.get("Primary (Hex)", "#2563EB"),
218                "secondary": best_color.get("Secondary (Hex)", "#3B82F6"),
219                "cta": best_color.get("CTA (Hex)", "#F97316"),
220                "background": best_color.get("Background (Hex)", "#F8FAFC"),
221                "text": best_color.get("Text (Hex)", "#1E293B"),
222                "notes": best_color.get("Notes", "")
223            },
224            "typography": {
225                "heading": best_typography.get("Heading Font", "Inter"),
226                "body": best_typography.get("Body Font", "Inter"),
227                "mood": best_typography.get("Mood/Style Keywords", reasoning.get("typography_mood", "")),
228                "best_for": best_typography.get("Best For", ""),
229                "google_fonts_url": best_typography.get("Google Fonts URL", ""),
230                "css_import": best_typography.get("CSS Import", "")
231            },
232            "key_effects": combined_effects,
233            "anti_patterns": reasoning.get("anti_patterns", ""),
234            "decision_rules": reasoning.get("decision_rules", {}),
235            "severity": reasoning.get("severity", "MEDIUM")
236        }
237 
238 
239# ============ OUTPUT FORMATTERS ============
240BOX_WIDTH = 90  # Wider box for more content
241 
242def format_ascii_box(design_system: dict) -> str:
243    """Format design system as ASCII box with emojis (MCP-style)."""
244    project = design_system.get("project_name", "PROJECT")
245    pattern = design_system.get("pattern", {})
246    style = design_system.get("style", {})
247    colors = design_system.get("colors", {})
248    typography = design_system.get("typography", {})
249    effects = design_system.get("key_effects", "")
250    anti_patterns = design_system.get("anti_patterns", "")
251 
252    def wrap_text(text: str, prefix: str, width: int) -> list:
253        """Wrap long text into multiple lines."""
254        if not text:
255            return []
256        words = text.split()
257        lines = []
258        current_line = prefix
259        for word in words:
260            if len(current_line) + len(word) + 1 <= width - 2:
261                current_line += (" " if current_line != prefix else "") + word
262            else:
263                if current_line != prefix:
264                    lines.append(current_line)
265                current_line = prefix + word
266        if current_line != prefix:
267            lines.append(current_line)
268        return lines
269 
270    # Build sections from pattern
271    sections = pattern.get("sections", "").split(">")
272    sections = [s.strip() for s in sections if s.strip()]
273 
274    # Build output lines
275    lines = []
276    w = BOX_WIDTH - 1
277 
278    lines.append("+" + "-" * w + "+")
279    lines.append(f"|  TARGET: {project} - RECOMMENDED DESIGN SYSTEM".ljust(BOX_WIDTH) + "|")
280    lines.append("+" + "-" * w + "+")
281    lines.append("|" + " " * BOX_WIDTH + "|")
282 
283    # Pattern section
284    lines.append(f"|  PATTERN: {pattern.get('name', '')}".ljust(BOX_WIDTH) + "|")
285    if pattern.get('conversion'):
286        lines.append(f"|     Conversion: {pattern.get('conversion', '')}".ljust(BOX_WIDTH) + "|")
287    if pattern.get('cta_placement'):
288        lines.append(f"|     CTA: {pattern.get('cta_placement', '')}".ljust(BOX_WIDTH) + "|")
289    lines.append("|     Sections:".ljust(BOX_WIDTH) + "|")
290    for i, section in enumerate(sections, 1):
291        lines.append(f"|       {i}. {section}".ljust(BOX_WIDTH) + "|")
292    lines.append("|" + " " * BOX_WIDTH + "|")
293 
294    # Style section
295    lines.append(f"|  STYLE: {style.get('name', '')}".ljust(BOX_WIDTH) + "|")
296    if style.get("keywords"):
297        for line in wrap_text(f"Keywords: {style.get('keywords', '')}", "|     ", BOX_WIDTH):
298            lines.append(line.ljust(BOX_WIDTH) + "|")
299    if style.get("best_for"):
300        for line in wrap_text(f"Best For: {style.get('best_for', '')}", "|     ", BOX_WIDTH):
301            lines.append(line.ljust(BOX_WIDTH) + "|")
302    if style.get("performance") or style.get("accessibility"):
303        perf_a11y = f"Performance: {style.get('performance', '')} | Accessibility: {style.get('accessibility', '')}"
304        lines.append(f"|     {perf_a11y}".ljust(BOX_WIDTH) + "|")
305    lines.append("|" + " " * BOX_WIDTH + "|")
306 
307    # Colors section
308    lines.append("|  COLORS:".ljust(BOX_WIDTH) + "|")
309    lines.append(f"|     Primary:    {colors.get('primary', '')}".ljust(BOX_WIDTH) + "|")
310    lines.append(f"|     Secondary:  {colors.get('secondary', '')}".ljust(BOX_WIDTH) + "|")
311    lines.append(f"|     CTA:        {colors.get('cta', '')}".ljust(BOX_WIDTH) + "|")
312    lines.append(f"|     Background: {colors.get('background', '')}".ljust(BOX_WIDTH) + "|")
313    lines.append(f"|     Text:       {colors.get('text', '')}".ljust(BOX_WIDTH) + "|")
314    if colors.get("notes"):
315        for line in wrap_text(f"Notes: {colors.get('notes', '')}", "|     ", BOX_WIDTH):
316            lines.append(line.ljust(BOX_WIDTH) + "|")
317    lines.append("|" + " " * BOX_WIDTH + "|")
318 
319    # Typography section
320    lines.append(f"|  TYPOGRAPHY: {typography.get('heading', '')} / {typography.get('body', '')}".ljust(BOX_WIDTH) + "|")
321    if typography.get("mood"):
322        for line in wrap_text(f"Mood: {typography.get('mood', '')}", "|     ", BOX_WIDTH):
323            lines.append(line.ljust(BOX_WIDTH) + "|")
324    if typography.get("best_for"):
325        for line in wrap_text(f"Best For: {typography.get('best_for', '')}", "|     ", BOX_WIDTH):
326            lines.append(line.ljust(BOX_WIDTH) + "|")
327    if typography.get("google_fonts_url"):
328        lines.append(f"|     Google Fonts: {typography.get('google_fonts_url', '')}".ljust(BOX_WIDTH) + "|")
329    if typography.get("css_import"):
330        lines.append(f"|     CSS Import: {typography.get('css_import', '')[:70]}...".ljust(BOX_WIDTH) + "|")
331    lines.append("|" + " " * BOX_WIDTH + "|")
332 
333    # Key Effects section
334    if effects:
335        lines.append("|  KEY EFFECTS:".ljust(BOX_WIDTH) + "|")
336        for line in wrap_text(effects, "|     ", BOX_WIDTH):
337            lines.append(line.ljust(BOX_WIDTH) + "|")
338        lines.append("|" + " " * BOX_WIDTH + "|")
339 
340    # Anti-patterns section
341    if anti_patterns:
342        lines.append("|  AVOID (Anti-patterns):".ljust(BOX_WIDTH) + "|")
343        for line in wrap_text(anti_patterns, "|     ", BOX_WIDTH):
344            lines.append(line.ljust(BOX_WIDTH) + "|")
345        lines.append("|" + " " * BOX_WIDTH + "|")
346 
347    # Pre-Delivery Checklist section
348    lines.append("|  PRE-DELIVERY CHECKLIST:".ljust(BOX_WIDTH) + "|")
349    checklist_items = [
350        "[ ] No emojis as icons (use SVG: Heroicons/Lucide)",
351        "[ ] cursor-pointer on all clickable elements",
352        "[ ] Hover states with smooth transitions (150-300ms)",
353        "[ ] Light mode: text contrast 4.5:1 minimum",
354        "[ ] Focus states visible for keyboard nav",
355        "[ ] prefers-reduced-motion respected",
356        "[ ] Responsive: 375px, 768px, 1024px, 1440px"
357    ]
358    for item in checklist_items:
359        lines.append(f"|     {item}".ljust(BOX_WIDTH) + "|")
360    lines.append("|" + " " * BOX_WIDTH + "|")
361 
362    lines.append("+" + "-" * w + "+")
363 
364