rebly-sections 1.0.1 → 1.2.0

package/assets/scripts/kb-synthesizer.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+"""
+KB Synthesizer — generate block-patterns.csv, settings-profiles.csv from aggregate-stats.json,
+and curate top components from analysis.jsonl into component-library.
+
+Usage:
+    python3 kb-synthesizer.py --stats themes/aggregate-stats.json \
+        --analysis themes/analysis.jsonl --extracted themes/extracted/ \
+        --kb src/rebly-sections/data/
+"""
+
+import argparse
+import csv
+import json
+import shutil
+import sys
+from pathlib import Path
+
+
+MIN_CATEGORY_SECTIONS = 5  # skip categories with fewer than this
+
+
+def generate_block_patterns(stats: dict, analysis_path: Path, out_path: Path):
+    """Generate block-patterns.csv from aggregate stats + analysis examples."""
+    rows = []
+    # Build lookup: find first example of each block combo per category
+    examples = {}  # (category, combo) -> first JSON example from JSONL
+    with open(analysis_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            rec = json.loads(line.strip())
+            cat = rec.get('category', '')
+            combo = '|'.join(sorted(rec.get('block_types', [])))
+            if combo and (cat, combo) not in examples:
+                examples[(cat, combo)] = rec
+
+    for cat, data in sorted(stats['categories'].items()):
+        if data['count'] < MIN_CATEGORY_SECTIONS:
+            continue
+        for rank, bc in enumerate(data.get('top_block_combos', [])[:8], 1):
+            combo = bc['combo']
+            rec = examples.get((cat, combo), {})
+            # Build a minimal JSON example from the record
+            block_types = combo.split('|')
+            json_ex = json.dumps([{"type": bt, "name": bt.replace('-', ' ').title()}
+                                  for bt in block_types], ensure_ascii=False)
+            common_settings = '|'.join(rec.get('setting_ids', [])[:6])
+            use_case = f"{cat} section with {' + '.join(block_types)} blocks"
+            rows.append({
+                'Category': cat,
+                'Block Type': combo,
+                'Common Settings': common_settings,
+                'Use Case': use_case,
+                'JSON Example': json_ex[:300],
+                'Frequency Rank': rank,
+            })
+
+    fieldnames = ['Category', 'Block Type', 'Common Settings', 'Use Case', 'JSON Example', 'Frequency Rank']
+    with open(out_path, 'w', newline='', encoding='utf-8') as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+    print(f"block-patterns.csv: {len(rows)} rows")
+
+
+def generate_settings_profiles(stats: dict, out_path: Path):
+    """Generate settings-profiles.csv from aggregate stats top setting IDs."""
+    rows = []
+    for cat, data in sorted(stats['categories'].items()):
+        if data['count'] < MIN_CATEGORY_SECTIONS:
+            continue
+        # Build type lookup from top_setting_types
+        type_lookup = {t['type']: t for t in data.get('top_setting_types', [])}
+
+        for rank, sid_entry in enumerate(data.get('top_setting_ids', [])[:10], 1):
+            sid = sid_entry['id']
+            # Infer setting type from ID name patterns
+            stype = _infer_setting_type(sid, type_lookup)
+            label = sid.replace('_', ' ').replace('-', ' ').title()
+            required = rank <= 3  # top 3 are "required"
+            rows.append({
+                'Section Type': cat,
+                'Setting ID': sid,
+                'Setting Type': stype,
+                'Label': label,
+                'Default': '',
+                'Required': str(required),
+                'Notes': f"Appears in {sid_entry['count']}/{data['count']} {cat} sections",
+                'Frequency Rank': rank,
+            })
+
+    fieldnames = ['Section Type', 'Setting ID', 'Setting Type', 'Label',
+                  'Default', 'Required', 'Notes', 'Frequency Rank']
+    with open(out_path, 'w', newline='', encoding='utf-8') as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+    print(f"settings-profiles.csv: {len(rows)} rows")
+
+
+def _infer_setting_type(setting_id: str, type_lookup: dict) -> str:
+    """Infer Shopify setting type from ID name."""
+    sid = setting_id.lower()
+    if 'image' in sid or 'photo' in sid or 'logo' in sid:
+        return 'image_picker'
+    if 'color' in sid and 'scheme' in sid:
+        return 'color_scheme'
+    if 'color' in sid:
+        return 'color'
+    if 'url' in sid or 'link' in sid:
+        return 'url'
+    if 'video' in sid:
+        return 'video_url'
+    if 'collection' in sid:
+        return 'collection'
+    if 'product' in sid:
+        return 'product'
+    if 'blog' in sid:
+        return 'blog'
+    if 'padding' in sid or 'margin' in sid or 'spacing' in sid or 'width' in sid or 'height' in sid:
+        return 'range'
+    if 'columns' in sid or 'count' in sid or 'limit' in sid or 'per_row' in sid:
+        return 'range'
+    if 'show' in sid or 'enable' in sid or 'hide' in sid:
+        return 'checkbox'
+    if 'layout' in sid or 'style' in sid or 'alignment' in sid or 'position' in sid:
+        return 'select'
+    if 'content' in sid or 'description' in sid or ('text' in sid and len(sid) > 6):
+        return 'richtext'
+    if 'heading' in sid or 'title' in sid or 'label' in sid or 'button' in sid:
+        return 'text'
+    if 'font' in sid:
+        return 'font_picker'
+    # Check if type_lookup has a dominant type
+    if type_lookup:
+        top = max(type_lookup.values(), key=lambda t: t.get('count', 0))
+        return top.get('type', 'text')
+    return 'text'
+
+
+def select_best_components(analysis_path: Path, extracted_dir: Path,
+                           component_dir: Path, index_path: Path):
+    """Pick top-scoring sections per category, copy to component library."""
+    # Score each section
+    scores = {}  # (category, theme_slug, filename) -> score
+    records = {}
+    with open(analysis_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            rec = json.loads(line.strip())
+            cat = rec.get('category', 'other')
+            key = (cat, rec['theme_slug'], rec['filename'])
+            score = rec.get('settings_count', 0) * 2
+            if rec.get('has_presets'):
+                score += 10
+            if rec.get('has_app_block'):
+                score += 5
+            if rec.get('blocks_count', 0) > 0:
+                score += 5
+            scores[key] = score
+            records[key] = rec
+
+    # Group by category, pick top 2 per category
+    from collections import defaultdict
+    by_cat = defaultdict(list)
+    for key, score in scores.items():
+        by_cat[key[0]].append((score, key))
+
+    # Load existing index
+    existing_slugs = set()
+    if index_path.exists():
+        with open(index_path, newline='', encoding='utf-8') as f:
+            for row in csv.DictReader(f):
+                existing_slugs.add(row.get('Slug', ''))
+
+    added = 0
+    new_rows = []
+    max_no = len(existing_slugs) + 1
+
+    for cat, entries in sorted(by_cat.items()):
+        if cat in ('other', 'header', 'footer', 'sidebar'):
+            continue  # skip non-section categories
+        entries.sort(reverse=True)
+        for score, (_, theme_slug, filename) in entries[:2]:
+            slug = filename.replace('.liquid', '')
+            # Avoid slug collisions with existing files
+            if slug in existing_slugs:
+                slug = f"{theme_slug}-{slug}"[:60]
+            if slug in existing_slugs:
+                continue
+
+            src = extracted_dir / theme_slug / 'sections' / filename
+            if not src.exists():
+                continue
+            dst = component_dir / f"{slug}.liquid"
+            shutil.copy2(src, dst)
+            existing_slugs.add(slug)
+
+            rec = records[(cat, theme_slug, filename)]
+            new_rows.append({
+                'No': max_no,
+                'Name': rec.get('schema_name', slug),
+                'Slug': slug,
+                'Category': cat,
+                'Keywords': f"{slug.replace('-', ' ')} {cat}",
+                'Difficulty': 'intermediate',
+                'Blocks Used': '|'.join(rec.get('block_types', []))[:80],
+                'Settings Count': rec.get('settings_count', 0),
+                'ui_style_keywords': f"{slug.replace('-', ' ')} {cat}",
+                'File': f"{slug}.liquid",
+                'Description': f"{rec.get('schema_name', slug)} section from {theme_slug}",
+                'Completeness': score,
+                'Has Presets': str(rec.get('has_presets', False)),
+                'Has App Block': str(rec.get('has_app_block', False)),
+            })
+            max_no += 1
+            added += 1
+
+    # Append to index
+    if new_rows:
+        fieldnames = list(new_rows[0].keys())
+        with open(index_path, 'a', newline='', encoding='utf-8') as f:
+            writer = csv.DictWriter(f, fieldnames=fieldnames)
+            for row in new_rows:
+                writer.writerow(row)
+
+    print(f"Components: {added} new curated files added to library")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Synthesize KB from analysis data")
+    parser.add_argument('--stats', default='themes/aggregate-stats.json')
+    parser.add_argument('--analysis', default='themes/analysis.jsonl')
+    parser.add_argument('--extracted', default='themes/extracted/')
+    parser.add_argument('--kb', default='src/rebly-sections/data/')
+    parser.add_argument('--mode', default='all', choices=['all', 'blocks', 'settings', 'components'])
+    args = parser.parse_args()
+
+    stats = json.loads(Path(args.stats).read_text(encoding='utf-8'))
+    kb_dir = Path(args.kb)
+
+    if args.mode in ('all', 'blocks'):
+        generate_block_patterns(stats, Path(args.analysis), kb_dir / 'block-patterns.csv')
+    if args.mode in ('all', 'settings'):
+        generate_settings_profiles(stats, kb_dir / 'settings-profiles.csv')
+    if args.mode in ('all', 'components'):
+        select_best_components(
+            Path(args.analysis), Path(args.extracted),
+            kb_dir / 'component-library', kb_dir / 'component-library' / '_index.csv')
+
+
+if __name__ == '__main__':
+    main()

package/assets/scripts/quality-gate-checks.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""Additional quality gate checks — WARN-level advisory checks for section quality."""
+
+import re
+
+
+def check_has_color_scheme(content, schema_json):
+    """Check if section schema includes color_scheme setting."""
+    if not schema_json:
+        return ("WARN", "No schema to check for color_scheme")
+    settings = schema_json.get("settings", [])
+    has_cs = any(s.get("type") == "color_scheme" for s in settings)
+    if has_cs:
+        return ("PASS", "color_scheme setting present")
+    return ("WARN", "Missing color_scheme setting — recommended for theme consistency")
+
+
+def check_has_font_picker(content, schema_json):
+    """Check if section schema includes at least one font_picker."""
+    if not schema_json:
+        return ("WARN", "No schema to check for font_picker")
+    settings = schema_json.get("settings", [])
+    has_fp = any(s.get("type") == "font_picker" for s in settings)
+    if has_fp:
+        return ("PASS", "font_picker setting present")
+    return ("WARN", "Missing font_picker — sections with headings should include typography control")
+
+
+def check_has_heading_tag(content, schema_json):
+    """Check if section has configurable heading tag for SEO."""
+    if not schema_json:
+        return ("WARN", "No schema to check for heading_tag")
+    settings = schema_json.get("settings", [])
+    has_ht = any(
+        s.get("id") in ("heading_tag", "heading_element", "tag")
+        and s.get("type") == "select"
+        for s in settings
+    )
+    if has_ht:
+        return ("PASS", "Heading tag configurable")
+    return ("WARN", "Missing heading_tag select — heading level should be merchant-configurable")
+
+
+def check_no_hardcoded_colors(content, schema_json):
+    """Check CSS doesn't contain hardcoded hex colors (outside Liquid variables)."""
+    style_match = re.search(r'<style[^>]*>(.*?)</style>', content, re.DOTALL)
+    if not style_match:
+        return ("PASS", "No style block found")
+    css = style_match.group(1)
+    # Strip Liquid variable references ({{ ... }}) before scanning
+    css_no_liquid = re.sub(r'\{\{.*?\}\}', '', css)
+    hex_colors = re.findall(r'#[0-9a-fA-F]{3,8}\b', css_no_liquid)
+    if hex_colors:
+        return ("WARN", f"Hardcoded colors in CSS: {', '.join(hex_colors[:5])} — use CSS variables instead")
+    return ("PASS", "No hardcoded colors in CSS")

package/assets/scripts/quality-gate.py

@@ -6,12 +6,23 @@ Usage: python3 quality-gate.py path/to/section.liquid [--json]
 """
 
 import argparse
+import importlib.util
 import json
 import re
 import sys
 from pathlib import Path
 
-
+# Import advisory checks from helper module (graceful fallback if missing)
+_checks_mod = None
+try:
+    _checks_path = Path(__file__).parent / 'quality-gate-checks.py'
+    _spec = importlib.util.spec_from_file_location('qg_checks', _checks_path)
+    _checks_mod = importlib.util.module_from_spec(_spec)
+    _spec.loader.exec_module(_checks_mod)
+except (FileNotFoundError, AttributeError):
+    pass
+
+# Core checks (PASS/FAIL)
 QUALITY_CHECKS = [
     ("schema_valid_json", "Schema block contains valid JSON"),
     ("has_presets", "Schema has non-empty presets array"),
@@ -26,6 +37,14 @@ QUALITY_CHECKS = [
     ("text_elements_explicit_color", "Text elements have explicit color in CSS"),
 ]
 
+# Advisory checks (PASS/WARN) — imported from quality-gate-checks.py
+ADVISORY_CHECKS = [
+    ("has_color_scheme", "color_scheme setting present"),
+    ("has_font_picker", "font_picker setting present"),
+    ("has_heading_tag", "Heading tag configurable via select"),
+    ("no_hardcoded_colors", "No hardcoded hex colors in CSS"),
+]
+
 
 def extract_schema_json(content):
     """Extract JSON from {% schema %} block"""
@@ -161,10 +180,13 @@ def run_quality_gate(filepath):
         return f"Error: File not found: {filepath}"
 
     content = path.read_text(encoding="utf-8")
+    schema_json = extract_schema_json(content)
     results = []
     passed = 0
     failed = 0
+    warned = 0
 
+    # Core checks (PASS/FAIL)
     for check_id, description in QUALITY_CHECKS:
         check_fn = CHECK_FUNCTIONS[check_id]
         try:
@@ -179,12 +201,44 @@ def run_quality_gate(filepath):
             failed += 1
             results.append(f"✗ {description}: ERROR ({e})")
 
+    # Advisory checks (PASS/WARN) — skip if helper module unavailable
+    if not _checks_mod:
+        advisory_fns = {}
+    else:
+        advisory_fns = {
+            "has_color_scheme": _checks_mod.check_has_color_scheme,
+            "has_font_picker": _checks_mod.check_has_font_picker,
+            "has_heading_tag": _checks_mod.check_has_heading_tag,
+            "no_hardcoded_colors": _checks_mod.check_no_hardcoded_colors,
+        }
+    for check_id, description in ADVISORY_CHECKS:
+        if check_id not in advisory_fns:
+            continue
+        check_fn = advisory_fns[check_id]
+        try:
+            status, message = check_fn(content, schema_json)
+            if status == "PASS":
+                passed += 1
+            else:
+                warned += 1
+            icon = "✓" if status == "PASS" else "⚠"
+            results.append(f"{icon} {message}: {status}")
+        except Exception as e:
+            warned += 1
+            results.append(f"⚠ {description}: ERROR ({e})")
+
+    total = passed + failed + warned
     summary = f"\n## Quality Gate: {path.name}\n"
-    summary += f"**Score:** {passed}/{passed + failed} checks passed\n\n"
+    summary += f"**Score:** {passed}/{total} checks passed"
+    if warned:
+        summary += f" ({warned} warnings)"
+    summary += "\n\n"
     summary += "\n".join(results)
 
     if failed == 0:
         summary += "\n\n**Result: PASS** ✓"
+        if warned:
+            summary += f" (with {warned} advisory warnings)"
     else:
         summary += f"\n\n**Result: FAIL** — {failed} issue(s) found"
 

package/assets/scripts/section-generator-helpers.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Helper search functions for section-generator.py — block patterns, settings profiles, theme DNA."""
+
+import sys
+from pathlib import Path
+
+_scripts_dir = str(Path(__file__).parent)
+if _scripts_dir not in sys.path:
+    sys.path.append(_scripts_dir)
+from core import search
+
+
+def search_block_patterns(description):
+    """Search block-patterns.csv for relevant block configurations."""
+    try:
+        result = search(description, domain="block-patterns", max_results=5)
+        if "error" in result or not result.get("results"):
+            return ""
+        lines = ["**Relevant Block Patterns:**"]
+        for r in result["results"]:
+            lines.append(f"- [{r.get('Category', '')} / {r.get('Block Type', '')}] {r.get('Use Case', '')}")
+            lines.append(f"  Settings: {r.get('Common Settings', '')}")
+            ex = r.get('JSON Example', '')
+            if ex:
+                lines.append(f"  Example: `{ex[:200]}`")
+        return "\n".join(lines)
+    except (FileNotFoundError, KeyError):
+        return ""
+
+
+def search_settings_profile(section_name):
+    """Search settings-profiles.csv for recommended settings for this section type."""
+    try:
+        result = search(section_name, domain="settings-profiles", max_results=8)
+        if "error" in result or not result.get("results"):
+            return ""
+        lines = ["**Recommended Settings Profile:**",
+                 "| Setting ID | Type | Label | Default | Required |",
+                 "|------------|------|-------|---------|----------|"]
+        for r in result["results"]:
+            lines.append(f"| {r.get('Setting ID', '')} | {r.get('Setting Type', '')} | "
+                         f"{r.get('Label', '')} | {r.get('Default', '')} | {r.get('Required', '')} |")
+        return "\n".join(lines)
+    except (FileNotFoundError, KeyError):
+        return ""
+
+
+def search_theme_dna(theme_name):
+    """Search theme-dna.csv for theme-specific conventions."""
+    try:
+        result = search(theme_name, domain="themes", max_results=1)
+        if "error" in result or not result.get("results"):
+            return ""
+        r = result["results"][0]
+        return (f"**Theme DNA:** {r.get('Theme', '')} — "
+                f"CSS Prefix: {r.get('CSS Variable Prefix', '')} | "
+                f"Naming: {r.get('Section Naming', '')} | "
+                f"Blocks: {r.get('Block Conventions', '')}")
+    except (FileNotFoundError, KeyError):
+        return ""
+
+
+def search_design_tokens(description):
+    """Search design-tokens.csv for relevant CSS tokens."""
+    try:
+        result = search(description, domain="tokens", max_results=5, min_score=0.3)
+        if "error" in result or not result.get("results"):
+            return ""
+        lines = ["**Relevant Design Tokens:**"]
+        for r in result["results"]:
+            lines.append(f"- `{r.get('CSS Variable', '')}`: {r.get('Value', '')} — {r.get('Usage', '')}")
+        return "\n".join(lines)
+    except (FileNotFoundError, KeyError):
+        return ""

package/assets/scripts/section-generator.py

@@ -6,6 +6,7 @@ Usage: python3 section-generator.py "name" "description" [--theme-profile path]
 """
 
 import argparse
+import re
 import sys
 import io
 from pathlib import Path
@@ -16,6 +17,17 @@ if _scripts_dir not in sys.path:
     sys.path.append(_scripts_dir)
 from core import search, search_component, DATA_DIR
 
+# Import helpers (kebab-case filename requires importlib)
+import importlib.util as _ilu
+_hp = Path(__file__).parent / 'section-generator-helpers.py'
+_hs = _ilu.spec_from_file_location('sg_helpers', _hp)
+_hm = _ilu.module_from_spec(_hs)
+_hs.loader.exec_module(_hm)
+search_block_patterns = _hm.search_block_patterns
+search_settings_profile = _hm.search_settings_profile
+search_theme_dna = _hm.search_theme_dna
+search_design_tokens = _hm.search_design_tokens
+
 TEMPLATE_DIR = Path(__file__).parent.parent / "templates"
 
 # UTF-8 stdout
@@ -38,8 +50,8 @@ def load_template(name):
     return ""
 
 
-def search_components(description, max_results=2):
-    """Search component library for closest pattern"""
+def search_components(description, max_results=1):
+    """Search component library for closest pattern — 1 full untruncated example"""
     result = search_component(description, max_results=max_results)
     if "error" in result or not result.get("results"):
         return "No matching component patterns found."
@@ -49,14 +61,14 @@ def search_components(description, max_results=2):
         output.append(f"**{r.get('Name', 'Unknown')}** ({r.get('Category', '')}, {r.get('Difficulty', '')})")
         output.append(f"Blocks: {r.get('Blocks Used', '')} | Settings: {r.get('Settings Count', '')}")
         if 'liquid_content' in r:
-            output.append(f"```liquid\n{r['liquid_content'][:2000]}\n```")
+            output.append(f"```liquid\n{r['liquid_content'][:6000]}\n```")
         output.append("")
     return "\n".join(output)
 
 
 def search_schema_settings(description, max_results=5):
     """Search schema-library for relevant setting types"""
-    result = search(description, domain="schema", max_results=max_results)
+    result = search(description, domain="schema", max_results=max_results, min_score=0.3)
     if "error" in result or not result.get("results"):
         return "No matching schema settings found."
 
@@ -71,7 +83,7 @@ def search_schema_settings(description, max_results=5):
 
 def search_best_practices(description, max_results=5):
     """Search best practices for applicable rules"""
-    result = search(description, domain="practices", max_results=max_results)
+    result = search(description, domain="practices", max_results=max_results, min_score=0.3)
     if "error" in result or not result.get("results"):
         return "No matching best practices found."
 
@@ -88,7 +100,7 @@ def search_best_practices(description, max_results=5):
 
 
 def try_ui_ux_bridge(ui_style_keywords):
-    """Optional: query ui-ux-pro-max if available"""
+    """Optional: query ui-ux-pro-max if available. Returns empty string if N/A."""
     try:
         ux_search_path = Path(__file__).parent.parent.parent.parent / ".claude" / "skills" / "ui-ux-pro-max" / "scripts" / "core.py"
         if not ux_search_path.exists():
@@ -101,17 +113,27 @@ def try_ui_ux_bridge(ui_style_keywords):
             spec.loader.exec_module(ux_module)
             result = ux_module.search(ui_style_keywords, domain="style", max_results=2)
             if result.get("results"):
-                lines = ["**UI/UX Style Recommendations (from ui-ux-pro-max):**"]
+                lines = ["<design_recommendations>", "**UI/UX Style Recommendations:**"]
                 for r in result["results"]:
                     lines.append(f"- {r.get('Style Category', '')}: {r.get('Keywords', '')}")
                     lines.append(f"  Effects: {r.get('Effects & Animation', '')}")
+                lines.append("</design_recommendations>")
                 return "\n".join(lines)
     except Exception:
         pass
-    return "N/A — ui-ux-pro-max not available"
+    # Return empty string instead of N/A to avoid wasting prompt tokens
+    return ""
+
+
+def _strip_empty_xml_tags(content):
+    """Remove XML tags whose body is empty or whitespace-only"""
+    return re.sub(r'<([\w-]+)>\s*</\1>', '', content)
 
 
-def assemble_context(name, description, theme_profile, component, schema, practices, design_recs):
+def assemble_context(name, description, theme_profile, component, schema,
+                     practices, design_recs, block_patterns="",
+                     settings_profile="", theme_dna="",
+                     design_tokens="", refinement=""):
     """Merge all context into generation prompt"""
     template = load_template("generation-prompt.md")
     base_template = load_template("section-base.liquid")
@@ -125,44 +147,19 @@ def assemble_context(name, description, theme_profile, component, schema, practi
         content = content.replace("{{ schema_search_results }}", schema)
         content = content.replace("{{ best_practices_results }}", practices)
         content = content.replace("{{ ui_ux_recommendations }}", design_recs)
+        content = content.replace("{{ block_patterns_results }}", block_patterns)
+        content = content.replace("{{ settings_profile_results }}", settings_profile)
+        content = content.replace("{{ theme_dna_context }}", theme_dna)
+        content = content.replace("{{ design_tokens_results }}", design_tokens)
+        content = content.replace("{{ refinement_context }}", refinement)
         base_block = f"```liquid\n{base_template}\n```" if base_template else "See standard OS2.0 section structure"
         content = content.replace("{{ section_base_content }}", base_block)
+        # Clean up empty XML tags from unused sections
+        content = _strip_empty_xml_tags(content)
         return content
 
-    # Fallback: manual assembly
-    return f"""# Generate Shopify Section: {name}
-
-## Description
-{description}
-
-## Theme Context
-{theme_profile}
-
-## Closest Pattern Template
-{component}
-
-## Relevant Schema Settings
-{schema}
-
-## Applicable Best Practices
-{practices}
-
-## Design Recommendations
-{design_recs}
-
-## Base Template
-```liquid
-{base_template}
-```
-
-## Requirements
-- OS2.0 compliant (presets, @app blocks, block.shopify_attributes)
-- Scoped CSS via #section-{{{{ section.id }}}}
-- Responsive (mobile-first)
-- Accessible (semantic HTML, aria-labels, alt text)
-- Performance (lazy-load non-hero images, no Liquid in CSS/JS)
-- Use {{% render %}} not {{% include %}}
-"""
+    # Fallback: manual assembly (shouldn't reach here with template present)
+    return f"# Generate Shopify Section: {name}\n\n{description}\n\n{component}\n\n{schema}\n\n{practices}"
 
 
 def main():
@@ -174,11 +171,18 @@ def main():
     args = parser.parse_args()
 
     theme = load_theme_profile(args.theme_profile)
+    # Tailored BM25 queries per domain for better relevance
     component = search_components(f"{args.name} {args.description}")
-    schema = search_schema_settings(args.description)
-    practices = search_best_practices(args.description)
+    schema = search_schema_settings(f"shopify section settings {args.description}")
+    practices = search_best_practices(f"shopify section {args.name} best practices")
     design_recs = try_ui_ux_bridge(args.name + " " + args.description)
+    blocks = search_block_patterns(f"{args.name} {args.description}")
+    profile = search_settings_profile(args.name)
+    dna = search_theme_dna(args.name)
+    tokens = search_design_tokens(f"css typography spacing color {args.description}")
 
+    # Build refinement context as dedicated section (not appended to component)
+    refinement = ""
     if args.refine:
         refine_path = Path(args.refine)
         try:
@@ -189,12 +193,18 @@ def main():
             try:
                 from quality_gate import run_quality_gate
                 gate_result = run_quality_gate(args.refine)
-                refine_context = f"\n## Existing Section (for refinement)\n```liquid\n{existing[:3000]}\n```\n\n## Quality Gate Results\n{gate_result}\n\nPlease fix the issues identified above while preserving the section's functionality."
-                component += refine_context
+                refinement = (f"<refinement>\n## Existing Section (for refinement)\n"
+                              f"```liquid\n{existing[:3000]}\n```\n\n"
+                              f"## Quality Gate Results\n{gate_result}\n\n"
+                              f"Please fix the issues identified above while preserving functionality.\n"
+                              f"</refinement>")
             except ImportError:
-                component += f"\n## Existing Section (for refinement)\n```liquid\n{existing[:3000]}\n```"
+                refinement = (f"<refinement>\n## Existing Section (for refinement)\n"
+                              f"```liquid\n{existing[:3000]}\n```\n</refinement>")
 
-    context = assemble_context(args.name, args.description, theme, component, schema, practices, design_recs)
+    context = assemble_context(args.name, args.description, theme, component, schema,
+                               practices, design_recs, blocks, profile, dna,
+                               design_tokens=tokens, refinement=refinement)
     print(context)