rebly-sections 1.0.0

package/assets/scripts/section-generator.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Rebly Sections Generator - Assemble context for Claude to generate Shopify sections
+Usage: python3 section-generator.py "name" "description" [--theme-profile path] [--refine path]
+"""
+
+import argparse
+import sys
+import io
+from pathlib import Path
+
+# Add scripts dir to path for sibling imports
+_scripts_dir = str(Path(__file__).parent)
+if _scripts_dir not in sys.path:
+    sys.path.append(_scripts_dir)
+from core import search, search_component, DATA_DIR
+
+TEMPLATE_DIR = Path(__file__).parent.parent / "templates"
+
+# UTF-8 stdout
+if sys.stdout.encoding and sys.stdout.encoding.lower() != 'utf-8':
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+
+
+def load_theme_profile(path):
+    """Load theme-profile.md or return defaults"""
+    if path and Path(path).exists():
+        return Path(path).read_text(encoding="utf-8")
+    return "No theme profile available. Use generic OS2.0 conventions:\n- CSS Variable Prefix: --\n- Section Naming: kebab-case\n- Follow standard OS2.0 patterns"
+
+
+def load_template(name):
+    """Load a template file"""
+    path = TEMPLATE_DIR / name
+    if path.exists():
+        return path.read_text(encoding="utf-8")
+    return ""
+
+
+def search_components(description, max_results=2):
+    """Search component library for closest pattern"""
+    result = search_component(description, max_results=max_results)
+    if "error" in result or not result.get("results"):
+        return "No matching component patterns found."
+
+    output = []
+    for r in result["results"]:
+        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("")
+    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)
+    if "error" in result or not result.get("results"):
+        return "No matching schema settings found."
+
+    output = []
+    for r in result["results"]:
+        output.append(f"- **{r.get('Type', '')}** ({r.get('Category', '')}): {r.get('Returns', '')} — Props: {r.get('Required Props', '')}")
+        json_ex = r.get('JSON Example', '')
+        if json_ex:
+            output.append(f"  ```json\n  {json_ex[:300]}\n  ```")
+    return "\n".join(output)
+
+
+def search_best_practices(description, max_results=5):
+    """Search best practices for applicable rules"""
+    result = search(description, domain="practices", max_results=max_results)
+    if "error" in result or not result.get("results"):
+        return "No matching best practices found."
+
+    output = []
+    for r in result["results"]:
+        output.append(f"- **[{r.get('Severity', '')}] {r.get('Rule', '')}**: {r.get('Description', '')}")
+        do = r.get('Do', '')
+        dont = r.get('Dont', '')
+        if do:
+            output.append(f"  - DO: {do}")
+        if dont:
+            output.append(f"  - DON'T: {dont}")
+    return "\n".join(output)
+
+
+def try_ui_ux_bridge(ui_style_keywords):
+    """Optional: query ui-ux-pro-max if available"""
+    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():
+            ux_search_path = Path(__file__).parent.parent.parent.parent / ".research" / "ui-ux-pro-max-skill" / "src" / "ui-ux-pro-max" / "scripts" / "core.py"
+
+        if ux_search_path.exists():
+            import importlib.util
+            spec = importlib.util.spec_from_file_location("ux_core", ux_search_path)
+            ux_module = importlib.util.module_from_spec(spec)
+            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):**"]
+                for r in result["results"]:
+                    lines.append(f"- {r.get('Style Category', '')}: {r.get('Keywords', '')}")
+                    lines.append(f"  Effects: {r.get('Effects & Animation', '')}")
+                return "\n".join(lines)
+    except Exception:
+        pass
+    return "N/A — ui-ux-pro-max not available"
+
+
+def assemble_context(name, description, theme_profile, component, schema, practices, design_recs):
+    """Merge all context into generation prompt"""
+    template = load_template("generation-prompt.md")
+    base_template = load_template("section-base.liquid")
+
+    if template:
+        content = template
+        content = content.replace("{{ name }}", name)
+        content = content.replace("{{ description }}", description)
+        content = content.replace("{{ theme_profile_summary }}", theme_profile)
+        content = content.replace("{{ component_pattern_content }}", component)
+        content = content.replace("{{ schema_search_results }}", schema)
+        content = content.replace("{{ best_practices_results }}", practices)
+        content = content.replace("{{ ui_ux_recommendations }}", design_recs)
+        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)
+        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 %}}
+"""
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Rebly Sections Generator")
+    parser.add_argument("name", help="Section name (e.g., 'hero', 'pricing-table')")
+    parser.add_argument("description", help="Section description")
+    parser.add_argument("--theme-profile", "-t", default=None, help="Path to theme-profile.md")
+    parser.add_argument("--refine", "-r", default=None, help="Path to existing section.liquid to refine")
+    args = parser.parse_args()
+
+    theme = load_theme_profile(args.theme_profile)
+    component = search_components(f"{args.name} {args.description}")
+    schema = search_schema_settings(args.description)
+    practices = search_best_practices(args.description)
+    design_recs = try_ui_ux_bridge(args.name + " " + args.description)
+
+    if args.refine:
+        refine_path = Path(args.refine)
+        try:
+            existing = refine_path.read_text(encoding="utf-8") if refine_path.exists() else None
+        except OSError:
+            existing = None
+        if existing:
+            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
+            except ImportError:
+                component += f"\n## Existing Section (for refinement)\n```liquid\n{existing[:3000]}\n```"
+
+    context = assemble_context(args.name, args.description, theme, component, schema, practices, design_recs)
+    print(context)
+
+
+if __name__ == "__main__":
+    main()

package/assets/scripts/theme-init.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Rebly Sections Theme Init - Scan Shopify theme and generate profile.
+Usage: python3 theme-init.py /path/to/theme [--output theme-profile.md]
+Stdlib only. No external dependencies.
+"""
+
+import argparse
+import csv
+import json
+import re
+import sys
+from pathlib import Path
+from datetime import date
+
+DATA_DIR = Path(__file__).parent.parent / "data"
+
+
+def detect_theme_info(theme_path: Path) -> dict:
+    """Read config/settings_schema.json for theme_info block."""
+    schema_path = theme_path / "config" / "settings_schema.json"
+    defaults = {"name": "Unknown", "version": "0.0.0", "author": "Unknown"}
+    if not schema_path.exists():
+        return defaults
+    try:
+        data = json.loads(schema_path.read_text(encoding="utf-8"))
+        if not isinstance(data, list):
+            return defaults
+        for item in data:
+            if isinstance(item, dict) and "theme_info" in item:
+                info = item["theme_info"]
+                return {"name": info.get("theme_name", "Unknown"),
+                        "version": info.get("theme_version", "0.0.0"),
+                        "author": info.get("theme_author", "Unknown")}
+        first = data[0] if data else {}
+        if isinstance(first, dict) and "name" in first:
+            return {"name": first["name"],
+                    "version": first.get("theme_version", "0.0.0"),
+                    "author": first.get("theme_author", "Unknown")}
+    except (json.JSONDecodeError, KeyError, IndexError):
+        pass
+    return defaults
+
+
+def scan_css_variables(theme_path: Path, max_files: int = 50) -> dict:
+    """Scan assets/*.css for CSS custom property prefixes, return top 10 by count."""
+    assets_dir = theme_path / "assets"
+    if not assets_dir.exists():
+        return {}
+    var_pattern = re.compile(r"--([\w]+)-")
+    counts: dict = {}
+    for css_file in list(assets_dir.glob("*.css"))[:max_files]:
+        try:
+            content = css_file.read_text(encoding="utf-8", errors="ignore")
+            for m in var_pattern.finditer(content):
+                p = m.group(1)
+                counts[p] = counts.get(p, 0) + 1
+        except Exception:
+            continue
+    return dict(sorted(counts.items(), key=lambda x: x[1], reverse=True)[:10])
+
+
+def analyze_sections(theme_path: Path) -> dict:
+    """List sections, extract naming conventions, count files."""
+    sections_dir = theme_path / "sections"
+    if not sections_dir.exists():
+        return {"count": 0, "patterns": [], "files": []}
+    files = [f.stem for f in sections_dir.glob("*.liquid")]
+    patterns: set = set()
+    for name in files:
+        if name.startswith("main-"):
+            patterns.add("main-* prefix")
+        if name.startswith("featured-"):
+            patterns.add("featured-* prefix")
+        if "-" in name:
+            patterns.add("kebab-case")
+        elif "_" in name:
+            patterns.add("snake_case")
+    return {"count": len(files), "patterns": sorted(patterns), "files": files[:20]}
+
+
+def match_theme_dna(theme_info: dict, dna_path: Path) -> dict | None:
+    """Match detected theme against theme-dna.csv by name then author+keyword."""
+    if not dna_path.exists():
+        return None
+    name_l = theme_info["name"].lower()
+    author_l = theme_info["author"].lower()
+    try:
+        with open(dna_path, "r", encoding="utf-8") as f:
+            rows = list(csv.DictReader(f))
+        for row in rows:
+            if name_l in row.get("Theme", "").lower():
+                return row
+        for row in rows:
+            if (author_l in row.get("Publisher", "").lower()
+                    and any(name_l in kw for kw in row.get("Keywords", "").lower().split(","))):
+                return row
+    except Exception:
+        pass
+    return None
+
+
+def generate_profile(theme_info: dict, css_vars: dict, sections: dict,
+                     dna: dict | None, output_path: str | None) -> str:
+    """Build and optionally write theme-profile.md content."""
+    d = dna or {}
+    top_prefix = f"--{list(css_vars.keys())[0]}-" if css_vars else "--"
+    detected_colors = ", ".join(f"--{k}-*" for k in list(css_vars.keys())[:5]) or "Not detected"
+    patterns_str = ", ".join(sections["patterns"]) if sections["patterns"] else "N/A"
+
+    lines = [
+        f"# Theme Profile: {theme_info['name']}",
+        f"Generated: {date.today()} | Version: {theme_info['version']} | Author: {theme_info['author']}",
+        "",
+        "## Conventions",
+        f"- CSS Variable Prefix: `{d.get('CSS Variable Prefix', top_prefix)}`" + ("" if dna else " (detected)"),
+        f"- Section Naming: {d.get('Section Naming', 'kebab-case')}",
+        f"- Block Convention: {d.get('Block Conventions', 'standard OS2.0')}",
+        "",
+        "## Design Tokens (from theme)",
+        f"- Color Scheme: {d.get('Color Scheme Pattern', detected_colors)}",
+        f"- Typography: {d.get('Typography Pattern', 'Use theme defaults')}",
+        f"- Spacing: {d.get('Spacing Pattern', 'Use theme defaults')}",
+        "",
+        "## Section Patterns",
+        f"- Detected sections: {sections['count']}",
+        f"- Naming patterns: {patterns_str}",
+        "",
+        "## Recommendations",
+    ]
+    if dna:
+        lines += [
+            f"- Follow {theme_info['name']} naming conventions",
+            f"- Use `{d.get('CSS Variable Prefix', '--')}` prefix for CSS variables",
+            f"- Match {d.get('Color Scheme Pattern', 'existing')} color scheme pattern",
+        ]
+    else:
+        lines += [
+            "- Use kebab-case for section file names",
+            "- Scope CSS with #shopify-section-{{ section.id }}",
+            "- Follow OS2.0 standards (presets, @app blocks)",
+        ]
+
+    content = "\n".join(lines) + "\n"
+    if output_path:
+        Path(output_path).write_text(content, encoding="utf-8")
+        print(f"Theme profile saved to: {output_path}")
+    return content
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Rebly Sections Theme Init — scan a Shopify theme and generate a profile.")
+    parser.add_argument("theme_path", help="Path to Shopify theme directory")
+    parser.add_argument("--output", "-o", default=None, help="Output path for theme-profile.md")
+    args = parser.parse_args()
+
+    theme_path = Path(args.theme_path)
+    if not theme_path.exists():
+        print(f"Error: Theme path not found: {theme_path}", file=sys.stderr)
+        sys.exit(1)
+
+    theme_info = detect_theme_info(theme_path)
+    print(f"Detected theme: {theme_info['name']} v{theme_info['version']} by {theme_info['author']}")
+
+    css_vars = scan_css_variables(theme_path)
+    print(f"CSS variable prefixes: {', '.join(f'--{k}-({v})' for k, v in list(css_vars.items())[:5]) or 'none detected'}")
+
+    sections = analyze_sections(theme_path)
+    print(f"Sections found: {sections['count']}")
+
+    dna_match = match_theme_dna(theme_info, DATA_DIR / "theme-dna.csv")
+    print(f"Theme DNA match: {dna_match.get('Theme', 'Unknown')}" if dna_match else "No exact DNA match — using generic OS2.0 profile")
+
+    profile = generate_profile(theme_info, css_vars, sections, dna_match, args.output or "theme-profile.md")
+    print(f"\n{profile}")
+
+
+if __name__ == "__main__":
+    main()

package/assets/templates/generation-prompt.md

@@ -0,0 +1,31 @@
+# Generate Shopify Section: {{ name }}
+
+## Description
+{{ description }}
+
+## Theme Context
+{{ theme_profile_summary }}
+
+## Closest Pattern Template
+{{ component_pattern_content }}
+
+## Relevant Schema Settings
+{{ schema_search_results }}
+
+## Applicable Best Practices
+{{ best_practices_results }}
+
+## Design Recommendations
+{{ ui_ux_recommendations }}
+
+## Base Template
+{{ section_base_content }}
+
+## 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 %}
+- Include {{ block.shopify_attributes }} on ALL block wrappers

package/assets/templates/section-base.liquid

@@ -0,0 +1,49 @@
+{%- comment -%}
+  rebly-sections: {{ name }}
+  Generated: {{ date }}
+  Theme: {{ theme_name }}
+{%- endcomment -%}
+
+{%- liquid
+  assign section_id = section.id
+-%}
+
+<section
+  id="section-{{ section_id }}"
+  class="rebly-{{ slug }} section-{{ section_id }}"
+>
+  <div class="page-width">
+    {%- comment -%} Section content goes here {%- endcomment -%}
+
+    {%- for block in section.blocks -%}
+      {%- case block.type -%}
+        {%- when '@app' -%}
+          <div {{ block.shopify_attributes }}>
+            {% render block %}
+          </div>
+        {%- comment -%} Custom block types go here {%- endcomment -%}
+      {%- endcase -%}
+    {%- endfor -%}
+  </div>
+</section>
+
+<style>
+  #section-{{ section_id }} {
+    padding: var(--section-padding-top) 0 var(--section-padding-bottom);
+  }
+</style>
+
+{% schema %}
+{
+  "name": "{{ display_name }}",
+  "tag": "section",
+  "class": "section",
+  "settings": [],
+  "blocks": [
+    { "type": "@app" }
+  ],
+  "presets": [
+    { "name": "{{ display_name }}" }
+  ]
+}
+{% endschema %}

package/assets/templates/theme-profile-template.md

@@ -0,0 +1,21 @@
+# Theme Profile: {theme_name}
+Generated: {date} | Version: {version} | Author: {author}
+
+## Conventions
+- CSS Variable Prefix: `{css_prefix}`
+- Section Naming: {naming_convention}
+- Block Convention: {block_convention}
+
+## Design Tokens (from theme)
+- Color Scheme: {color_scheme}
+- Typography: {typography}
+- Spacing: {spacing}
+
+## Section Patterns
+- Detected sections: {section_count}
+- Naming patterns: {naming_patterns}
+
+## Recommendations
+- {rec_1}
+- {rec_2}
+- {rec_3}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(cwd: string): void;

package/dist/commands/init.js

@@ -0,0 +1,70 @@
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+import { detectPlatforms } from '../utils/detect-platform.js';
+import { copyAssets } from '../utils/copy-assets.js';
+export function init(cwd) {
+    console.log('rebly-sections installer\n');
+    const targets = detectPlatforms(cwd);
+    if (targets.length === 0) {
+        console.log('No .claude/ or .agent/ directory detected.');
+        console.log('');
+        console.log('To use with Claude Code:');
+        console.log('  mkdir -p .claude/skills');
+        console.log('  npx rebly-sections init');
+        console.log('');
+        console.log('To use with Antigravity Kit:');
+        console.log('  mkdir -p .agent/skills');
+        console.log('  npx rebly-sections init');
+        process.exit(1);
+    }
+    // In dist/commands/init.js -> assets is at ../../assets/
+    const scriptDir = dirname(fileURLToPath(import.meta.url));
+    const assetsDir = join(scriptDir, '..', '..', 'assets');
+    if (!existsSync(assetsDir)) {
+        console.error('Error: Assets directory not found. Package may be corrupted.');
+        process.exit(1);
+    }
+    const commandsDir = join(assetsDir, 'commands');
+    for (const target of targets) {
+        console.log(`Installing to ${target.platform}...`);
+        console.log(`  Target: ${target.targetDir}`);
+        try {
+            const fileCount = copyAssets(assetsDir, target.targetDir);
+            console.log(`  Copied ${fileCount} files`);
+        }
+        catch (err) {
+            console.error(`  Error: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+        }
+        // Install slash commands to .claude/commands/ or .agent/commands/
+        if (existsSync(commandsDir)) {
+            const platformDir = join(cwd, target.platform === 'claude' ? '.claude' : '.agent');
+            const targetCommandsDir = join(platformDir, 'commands');
+            try {
+                const cmdCount = copyAssets(commandsDir, targetCommandsDir);
+                console.log(`  Installed ${cmdCount} slash commands (/theme-init, /section)\n`);
+            }
+            catch (err) {
+                console.error(`  Warning: Could not install slash commands: ${err instanceof Error ? err.message : err}\n`);
+            }
+        }
+    }
+    console.log('Checking Python...');
+    try {
+        const version = execSync('python3 --version', { encoding: 'utf-8' }).trim();
+        console.log(`  ${version}`);
+    }
+    catch {
+        console.log('  Warning: python3 not found. Python 3.x is required for search scripts.');
+    }
+    console.log('\nInstallation complete!\n');
+    console.log('Usage:');
+    console.log('  /theme-init — Scan your Shopify theme');
+    console.log('  /section — Generate a new section');
+    console.log('');
+    console.log('Search:');
+    console.log('  python3 scripts/search.py "hero section" --component');
+    console.log('  python3 scripts/search.py "image_picker" --domain schema');
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { init } from './commands/init.js';
+const args = process.argv.slice(2);
+const command = args[0];
+if (command === 'init') {
+    init(process.cwd());
+}
+else {
+    console.log('rebly-sections - Shopify section AI skill installer\n');
+    console.log('Usage: npx rebly-sections init\n');
+    console.log('Commands:');
+    console.log('  init    Install rebly-sections skill to detected platform(s)');
+    process.exit(command ? 1 : 0);
+}

package/dist/utils/copy-assets.d.ts

@@ -0,0 +1 @@
+export declare function copyAssets(assetsDir: string, targetDir: string): number;

package/dist/utils/copy-assets.js

@@ -0,0 +1,44 @@
+import { cpSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+const SKIP_PATTERNS = ['.gitkeep', '__pycache__', '.pyc', '.DS_Store', 'commands'];
+function shouldSkip(name) {
+    return SKIP_PATTERNS.some(p => name.includes(p));
+}
+export function copyAssets(assetsDir, targetDir) {
+    if (!existsSync(assetsDir)) {
+        throw new Error(`Assets directory not found: ${assetsDir}`);
+    }
+    if (!existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+    }
+    let fileCount = 0;
+    const entries = readdirSync(assetsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (shouldSkip(entry.name))
+            continue;
+        const srcPath = join(assetsDir, entry.name);
+        const destPath = join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            cpSync(srcPath, destPath, { recursive: true, filter: (src) => !shouldSkip(src) });
+            fileCount += countFiles(destPath);
+        }
+        else {
+            cpSync(srcPath, destPath);
+            fileCount++;
+        }
+    }
+    return fileCount;
+}
+function countFiles(dir) {
+    let count = 0;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            count += countFiles(join(dir, entry.name));
+        }
+        else {
+            count++;
+        }
+    }
+    return count;
+}

package/dist/utils/detect-platform.d.ts

@@ -0,0 +1,6 @@
+export type Platform = 'claude' | 'antigravity';
+export interface PlatformTarget {
+    platform: Platform;
+    targetDir: string;
+}
+export declare function detectPlatforms(cwd: string): PlatformTarget[];

package/dist/utils/detect-platform.js

@@ -0,0 +1,18 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+export function detectPlatforms(cwd) {
+    const targets = [];
+    if (existsSync(join(cwd, '.claude'))) {
+        targets.push({
+            platform: 'claude',
+            targetDir: join(cwd, '.claude', 'skills', 'rebly-sections')
+        });
+    }
+    if (existsSync(join(cwd, '.agent'))) {
+        targets.push({
+            platform: 'antigravity',
+            targetDir: join(cwd, '.agent', 'skills', 'rebly-sections')
+        });
+    }
+    return targets;
+}