td-ai-tools 1.0.2

package/skills/everhour-basecamp-estimates/scripts/update_estimates.py

@@ -0,0 +1,518 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode
+from urllib.request import Request, urlopen
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_ENV_FILE = SKILL_ROOT / ".env"
+EVERHOUR_BASE_URL = "https://api.everhour.com"
+TITLE_KEYS = ("title", "name", "content", "text")
+TRAILING_ESTIMATE_RE = re.compile(r"\s+\[(\d+(?:\.\d+)?)h\]$", re.IGNORECASE)
+WHITESPACE_RE = re.compile(r"\s+")
+
+
+@dataclass(frozen=True)
+class TodoItem:
+    id: str
+    title: str
+
+
+@dataclass(frozen=True)
+class MatchPlan:
+    todo: TodoItem
+    hours: Decimal
+    seconds: int
+    everhour_task_id: str
+    everhour_task_name: str
+    new_basecamp_title: str
+
+
+@dataclass(frozen=True)
+class TodoSelection:
+    active: list[TodoItem]
+    skipped_completed: list[TodoItem]
+
+
+class ScriptError(RuntimeError):
+    pass
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Update Everhour estimates for tasks matched from a Basecamp todo or "
+            "todolist URL, then append the estimate to the Basecamp todo titles."
+        )
+    )
+    parser.add_argument("basecamp_url", help="Basecamp todo or todolist URL")
+    parser.add_argument(
+        "hours",
+        help="Estimate in hours, or a JSON array of per-task estimates in hours",
+    )
+    parser.add_argument(
+        "--env-file",
+        default=str(DEFAULT_ENV_FILE),
+        help=f"Path to the skill-local .env file (default: {DEFAULT_ENV_FILE})",
+    )
+    parser.add_argument(
+        "--basecamp-bin",
+        default="basecamp",
+        help="Basecamp CLI executable name or path",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print the planned changes without mutating Everhour or Basecamp",
+    )
+    return parser.parse_args()
+
+
+def load_env_file(path: Path) -> dict[str, str]:
+    if not path.exists():
+        raise ScriptError(
+            f"Missing env file: {path}. Copy {SKILL_ROOT / '.env.example'} to "
+            f"{path} and fill in the values."
+        )
+
+    values: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        if "=" not in stripped:
+            raise ScriptError(f"Invalid line in {path}: {line}")
+        key, raw_value = stripped.split("=", 1)
+        values[key.strip()] = raw_value.strip().strip("'").strip('"')
+
+    for key, value in os.environ.items():
+        if key.startswith("EVERHOUR_"):
+            values[key] = value
+
+    missing = [key for key in ("EVERHOUR_API_KEY", "EVERHOUR_PROJECT_ID") if not values.get(key)]
+    if missing:
+        raise ScriptError(f"Missing required environment values: {', '.join(missing)}")
+
+    return values
+
+
+def parse_hours_to_seconds(raw_hours: str) -> tuple[Decimal, int]:
+    return parse_hours_value(raw_hours)
+
+
+def parse_hours_value(raw_hours: Any) -> tuple[Decimal, int]:
+    if isinstance(raw_hours, bool):
+        raise ScriptError(f"Invalid hours value: {raw_hours}")
+
+    if isinstance(raw_hours, Decimal):
+        hours = raw_hours
+    else:
+        try:
+            hours = Decimal(str(raw_hours))
+        except (InvalidOperation, ValueError) as exc:
+            raise ScriptError(f"Invalid hours value: {raw_hours}") from exc
+
+    if hours <= 0:
+        raise ScriptError("Hours must be greater than zero.")
+
+    seconds = int((hours * Decimal("3600")).quantize(Decimal("1"), rounding=ROUND_HALF_UP))
+    return hours, seconds
+
+
+def parse_hours_input(raw_hours: str, todo_count: int) -> list[tuple[Decimal, int]]:
+    stripped = raw_hours.strip()
+    if stripped.startswith("["):
+        try:
+            values = json.loads(stripped, parse_float=Decimal, parse_int=Decimal)
+        except json.JSONDecodeError as exc:
+            raise ScriptError(f"Invalid hours array: {raw_hours}") from exc
+
+        if not isinstance(values, list):
+            raise ScriptError("Hours array input must decode to a JSON array.")
+        if len(values) != todo_count:
+            raise ScriptError(
+                "Hours array length does not match active Basecamp todo count: "
+                f"expected {todo_count}, got {len(values)}."
+            )
+        return [parse_hours_value(value) for value in values]
+
+    hours, seconds = parse_hours_to_seconds(raw_hours)
+    return [(hours, seconds) for _ in range(todo_count)]
+
+
+def format_hours(hours: Decimal) -> str:
+    rendered = format(hours.normalize(), "f")
+    return rendered.rstrip("0").rstrip(".") if "." in rendered else rendered
+
+
+def strip_estimate_suffix(title: str) -> str:
+    return TRAILING_ESTIMATE_RE.sub("", title).strip()
+
+
+def normalize_title(title: str) -> str:
+    collapsed = WHITESPACE_RE.sub(" ", strip_estimate_suffix(title)).strip()
+    return collapsed.casefold()
+
+
+def build_estimated_title(title: str, hours: Decimal) -> str:
+    return f"{strip_estimate_suffix(title)} [{format_hours(hours)}h]"
+
+
+def run_basecamp_json(basecamp_bin: str, *args: str) -> Any:
+    command = [basecamp_bin, *args, "--agent"]
+    completed = subprocess.run(command, capture_output=True, text=True)
+    if completed.returncode != 0:
+        stderr = completed.stderr.strip()
+        stdout = completed.stdout.strip()
+        raise ScriptError(
+            f"Basecamp command failed: {' '.join(command)}\n"
+            f"{stderr or stdout or 'No output returned.'}"
+        )
+
+    stdout = completed.stdout.strip()
+    if not stdout:
+        raise ScriptError(f"Basecamp command returned no JSON: {' '.join(command)}")
+
+    try:
+        return json.loads(stdout)
+    except json.JSONDecodeError as exc:
+        raise ScriptError(
+            f"Basecamp command returned invalid JSON: {' '.join(command)}\n{stdout}"
+        ) from exc
+
+
+def extract_title(record: dict[str, Any]) -> str:
+    for key in TITLE_KEYS:
+        value = record.get(key)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    raise ScriptError(f"Could not determine a title from Basecamp payload: {record}")
+
+
+def extract_todo_objects(payload: Any) -> list[dict[str, Any]]:
+    if isinstance(payload, list):
+        candidates = [item for item in payload if is_todo_like(item)]
+        if candidates:
+            return candidates
+        return []
+
+    if not isinstance(payload, dict):
+        return []
+
+    for key in ("todos", "items", "entries", "records"):
+        value = payload.get(key)
+        if isinstance(value, list):
+            candidates = [item for item in value if is_todo_like(item)]
+            if candidates:
+                return candidates
+
+    for key, value in payload.items():
+        if "todo" in key.lower():
+            candidates = extract_todo_objects(value)
+            if candidates:
+                return candidates
+
+    for value in payload.values():
+        candidates = extract_todo_objects(value)
+        if candidates:
+            return candidates
+
+    return []
+
+
+def is_todo_like(value: Any) -> bool:
+    return (
+        isinstance(value, dict)
+        and "id" in value
+        and any(isinstance(value.get(key), str) and value.get(key).strip() for key in TITLE_KEYS)
+    )
+
+
+def is_todo_completed(record: dict[str, Any]) -> bool:
+    if record.get("completed") is True:
+        return True
+
+    status = record.get("status")
+    if isinstance(status, str) and status.strip().lower() in {"complete", "completed", "done", "closed"}:
+        return True
+
+    for key in ("completedAt", "completed_at", "completedOn", "completed_on"):
+        value = record.get(key)
+        if isinstance(value, str) and value.strip():
+            return True
+
+    return False
+
+
+def load_basecamp_todos(basecamp_bin: str, basecamp_url: str) -> TodoSelection:
+    parsed = run_basecamp_json(basecamp_bin, "url", "parse", basecamp_url)
+    resource_type = str(parsed.get("type", "")).strip().lower()
+
+    if resource_type in {"todo", "todos"}:
+        payload = run_basecamp_json(basecamp_bin, "todos", "show", basecamp_url)
+        todo = TodoItem(id=str(payload["id"]), title=extract_title(payload))
+        if is_todo_completed(payload):
+            return TodoSelection(active=[], skipped_completed=[todo])
+        return TodoSelection(active=[todo], skipped_completed=[])
+
+    if resource_type in {"todolist", "todolists"}:
+        payload = run_basecamp_json(basecamp_bin, "todolists", "show", basecamp_url)
+        todo_objects = extract_todo_objects(payload)
+        if not todo_objects:
+            raise ScriptError(
+                "The Basecamp todolist payload did not include any todo items. "
+                "Inspect the todolist manually to confirm the CLI output shape."
+            )
+        active: list[TodoItem] = []
+        skipped_completed: list[TodoItem] = []
+        for item in todo_objects:
+            todo = TodoItem(id=str(item["id"]), title=extract_title(item))
+            if is_todo_completed(item):
+                skipped_completed.append(todo)
+            else:
+                active.append(todo)
+        return TodoSelection(active=active, skipped_completed=skipped_completed)
+
+    raise ScriptError(
+        f"Unsupported Basecamp URL type: {resource_type or 'unknown'}. "
+        "Use a todo or todolist URL."
+    )
+
+
+class EverhourClient:
+    def __init__(self, api_key: str, project_id: str) -> None:
+        self.api_key = api_key
+        self.project_id = project_id
+        self._open_tasks_by_title: dict[str, list[dict[str, Any]]] | None = None
+
+    def _request(self, method: str, path: str, payload: dict[str, Any] | None = None) -> Any:
+        request = Request(
+            url=f"{EVERHOUR_BASE_URL}{path}",
+            method=method,
+            headers={
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "X-Api-Key": self.api_key,
+            },
+            data=None if payload is None else json.dumps(payload).encode("utf-8"),
+        )
+
+        try:
+            with urlopen(request) as response:
+                raw_body = response.read().decode("utf-8")
+        except HTTPError as exc:
+            body = exc.read().decode("utf-8", errors="replace")
+            raise ScriptError(f"Everhour API error {exc.code} for {method} {path}: {body}") from exc
+        except URLError as exc:
+            raise ScriptError(f"Everhour API request failed for {method} {path}: {exc.reason}") from exc
+
+        if not raw_body:
+            return None
+
+        try:
+            return json.loads(raw_body)
+        except json.JSONDecodeError as exc:
+            raise ScriptError(f"Everhour API returned invalid JSON for {method} {path}: {raw_body}") from exc
+
+    def _project_path(self, suffix: str) -> str:
+        return f"/projects/{quote(self.project_id, safe='')}{suffix}"
+
+    def _task_path(self, task_id: str, suffix: str = "") -> str:
+        return f"/tasks/{quote(task_id, safe='')}{suffix}"
+
+    def list_open_tasks(self) -> dict[str, list[dict[str, Any]]]:
+        if self._open_tasks_by_title is not None:
+            return self._open_tasks_by_title
+
+        tasks_by_title: dict[str, list[dict[str, Any]]] = {}
+        page = 1
+        limit = 100
+
+        while True:
+            query = urlencode({"limit": limit, "page": page})
+            tasks = self._request("GET", self._project_path(f"/tasks?{query}"))
+            if not isinstance(tasks, list):
+                raise ScriptError("Everhour project tasks response was not a list.")
+
+            for task in tasks:
+                if not isinstance(task, dict) or "id" not in task:
+                    continue
+                tasks_by_title.setdefault(normalize_title(str(task.get("name", ""))), []).append(task)
+
+            if len(tasks) < limit:
+                break
+            page += 1
+
+        self._open_tasks_by_title = tasks_by_title
+        return tasks_by_title
+
+    def search_tasks(self, title: str) -> list[dict[str, Any]]:
+        query = urlencode(
+            {
+                "query": title,
+                "limit": 100,
+                "searchInClosed": "true",
+            }
+        )
+        tasks = self._request("GET", self._project_path(f"/tasks/search?{query}"))
+        if not isinstance(tasks, list):
+            raise ScriptError("Everhour task search response was not a list.")
+        return [task for task in tasks if isinstance(task, dict)]
+
+    def match_task(self, title: str) -> dict[str, Any]:
+        normalized = normalize_title(title)
+        open_matches = self.list_open_tasks().get(normalized, [])
+        if len(open_matches) == 1:
+            return open_matches[0]
+        if len(open_matches) > 1:
+            matches = ", ".join(str(task.get("id")) for task in open_matches)
+            raise ScriptError(f"Ambiguous Everhour matches for '{title}': {matches}")
+
+        search_matches = [
+            task
+            for task in self.search_tasks(strip_estimate_suffix(title))
+            if normalize_title(str(task.get("name", ""))) == normalized
+        ]
+        if not search_matches:
+            raise ScriptError(
+                f"No Everhour task match found for Basecamp title '{title}' in project {self.project_id}."
+            )
+        if len(search_matches) > 1:
+            matches = ", ".join(str(task.get("id")) for task in search_matches)
+            raise ScriptError(f"Ambiguous Everhour matches for '{title}': {matches}")
+        return search_matches[0]
+
+    def update_task_estimate(self, task_id: str, total_seconds: int) -> None:
+        self._request(
+            "PUT",
+            self._task_path(task_id, "/estimate"),
+            {"total": total_seconds, "type": "overall"},
+        )
+
+
+def update_basecamp_title(basecamp_bin: str, todo_id: str, title: str) -> None:
+    run_basecamp_json(basecamp_bin, "todos", "update", todo_id, "--title", title)
+
+
+def build_plan(
+    todos: list[TodoItem],
+    estimates: list[tuple[Decimal, int]],
+    everhour: EverhourClient,
+) -> list[MatchPlan]:
+    if len(todos) != len(estimates):
+        raise ScriptError(
+            "Estimate count does not match todo count: "
+            f"expected {len(todos)}, got {len(estimates)}."
+        )
+
+    plans: list[MatchPlan] = []
+    seen_titles: dict[str, TodoItem] = {}
+    seen_task_ids: dict[str, MatchPlan] = {}
+    for todo, (hours, seconds) in zip(todos, estimates):
+        normalized_title = normalize_title(todo.title)
+        prior_todo = seen_titles.get(normalized_title)
+        if prior_todo is not None:
+            raise ScriptError(
+                "Cannot map Basecamp todos one-to-one to Everhour tasks because "
+                f"'{todo.title}' duplicates todo {prior_todo.id} after normalization "
+                f"(conflicts with todo {todo.id})."
+            )
+        seen_titles[normalized_title] = todo
+
+        task = everhour.match_task(todo.title)
+        task_id = str(task.get("id", "")).strip()
+        task_name = str(task.get("name", "")).strip()
+        if not task_id or not task_name:
+            raise ScriptError(f"Everhour task payload missing id or name: {task}")
+        plan = MatchPlan(
+            todo=todo,
+            hours=hours,
+            seconds=seconds,
+            everhour_task_id=task_id,
+            everhour_task_name=task_name,
+            new_basecamp_title=build_estimated_title(todo.title, hours),
+        )
+        prior_plan = seen_task_ids.get(task_id)
+        if prior_plan is not None:
+            raise ScriptError(
+                "Cannot update the same Everhour task for multiple Basecamp todos: "
+                f"todo {prior_plan.todo.id} and todo {todo.id} both matched Everhour "
+                f"task {task_id} ({task_name})."
+            )
+        seen_task_ids[task_id] = plan
+        plans.append(plan)
+    return plans
+
+
+def print_plan(
+    plans: list[MatchPlan],
+    skipped_completed: list[TodoItem],
+    dry_run: bool,
+) -> None:
+    mode = "DRY RUN" if dry_run else "PLAN"
+    distinct_estimates = {(plan.hours, plan.seconds) for plan in plans}
+    if len(distinct_estimates) == 1:
+        hours, seconds = next(iter(distinct_estimates))
+        print(f"{mode}: apply {format_hours(hours)}h ({seconds} seconds) to {len(plans)} task(s)")
+    else:
+        print(f"{mode}: apply per-task estimates to {len(plans)} task(s)")
+    if skipped_completed:
+        print(f"Skipping {len(skipped_completed)} completed Basecamp todo(s):")
+        for todo in skipped_completed:
+            print(f"- Basecamp todo {todo.id}: {todo.title}")
+    for plan in plans:
+        print(
+            f"- Basecamp todo {plan.todo.id}: {plan.todo.title}\n"
+            f"  Everhour task {plan.everhour_task_id}: {plan.everhour_task_name}\n"
+            f"  Estimate: {format_hours(plan.hours)}h ({plan.seconds} seconds)\n"
+            f"  New Basecamp title: {plan.new_basecamp_title}"
+        )
+
+
+def main() -> int:
+    args = parse_args()
+    env = load_env_file(Path(args.env_file))
+    selection = load_basecamp_todos(args.basecamp_bin, args.basecamp_url)
+    if not selection.active:
+        if selection.skipped_completed:
+            raise ScriptError("All matching Basecamp todos are already completed; nothing to update.")
+        raise ScriptError("No Basecamp todos were found for the provided URL.")
+    estimates = parse_hours_input(args.hours, len(selection.active))
+
+    everhour = EverhourClient(
+        api_key=env["EVERHOUR_API_KEY"],
+        project_id=env["EVERHOUR_PROJECT_ID"],
+    )
+    plans = build_plan(selection.active, estimates, everhour)
+    print_plan(plans, selection.skipped_completed, dry_run=args.dry_run)
+
+    if args.dry_run:
+        return 0
+
+    for plan in plans:
+        everhour.update_task_estimate(plan.everhour_task_id, plan.seconds)
+
+    for plan in plans:
+        update_basecamp_title(args.basecamp_bin, plan.todo.id, plan.new_basecamp_title)
+
+    print("Completed Everhour estimate updates and Basecamp title updates.")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except ScriptError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        raise SystemExit(1)

package/skills/everhour-basecamp-estimates/tests/test_update_estimates.py

@@ -0,0 +1,93 @@
+import importlib.util
+import sys
+import unittest
+from decimal import Decimal
+from pathlib import Path
+from unittest import mock
+
+
+SCRIPT_PATH = (
+    Path(__file__).resolve().parents[1] / "scripts" / "update_estimates.py"
+)
+SPEC = importlib.util.spec_from_file_location("update_estimates", SCRIPT_PATH)
+MODULE = importlib.util.module_from_spec(SPEC)
+assert SPEC.loader is not None
+sys.modules[SPEC.name] = MODULE
+SPEC.loader.exec_module(MODULE)
+
+
+class ParseHoursInputTest(unittest.TestCase):
+    def test_scalar_hours_are_reused_for_each_todo(self) -> None:
+        estimates = MODULE.parse_hours_input("2.5", 3)
+
+        self.assertEqual(
+            estimates,
+            [
+                (Decimal("2.5"), 9000),
+                (Decimal("2.5"), 9000),
+                (Decimal("2.5"), 9000),
+            ],
+        )
+
+    def test_json_array_hours_map_one_to_one(self) -> None:
+        estimates = MODULE.parse_hours_input("[1,2.5,\"4\"]", 3)
+
+        self.assertEqual(
+            estimates,
+            [
+                (Decimal("1"), 3600),
+                (Decimal("2.5"), 9000),
+                (Decimal("4"), 14400),
+            ],
+        )
+
+    def test_json_array_length_must_match_active_todos(self) -> None:
+        with self.assertRaises(MODULE.ScriptError) as caught:
+            MODULE.parse_hours_input("[1,2.5]", 3)
+
+        self.assertIn("expected 3, got 2", str(caught.exception))
+
+
+class BuildPlanTest(unittest.TestCase):
+    def test_rejects_duplicate_normalized_basecamp_titles(self) -> None:
+        todos = [
+            MODULE.TodoItem(id="1", title="Ship estimate"),
+            MODULE.TodoItem(id="2", title="Ship estimate [1h]"),
+        ]
+        estimates = [
+            (Decimal("1"), 3600),
+            (Decimal("2"), 7200),
+        ]
+        everhour = mock.Mock()
+        everhour.match_task.return_value = {"id": "abc123", "name": "Ship estimate"}
+
+        with self.assertRaises(MODULE.ScriptError) as caught:
+            MODULE.build_plan(todos, estimates, everhour)
+
+        self.assertIn("duplicates todo 1", str(caught.exception))
+        everhour.match_task.assert_called_once_with("Ship estimate")
+
+    def test_rejects_duplicate_everhour_task_matches(self) -> None:
+        todos = [
+            MODULE.TodoItem(id="1", title="First task"),
+            MODULE.TodoItem(id="2", title="Second task"),
+        ]
+        estimates = [
+            (Decimal("1"), 3600),
+            (Decimal("2"), 7200),
+        ]
+        everhour = mock.Mock()
+        everhour.match_task.side_effect = [
+            {"id": "abc123", "name": "Shared task"},
+            {"id": "abc123", "name": "Shared task"},
+        ]
+
+        with self.assertRaises(MODULE.ScriptError) as caught:
+            MODULE.build_plan(todos, estimates, everhour)
+
+        self.assertIn("todo 1 and todo 2", str(caught.exception))
+        self.assertEqual(everhour.match_task.call_count, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/horizon-component-migration/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: horizon-component-migration
+description: Bundle Shopify Horizon components into a migration package for a different theme, including recursive dependencies across sections, snippets, blocks, assets, templates, and locale strings. Use when asked to port or extract a Horizon component with all required files and setup notes.
+---
+
+# Horizon Component Migration
+
+## Workflow
+
+1. Scan the source theme before selecting files.
+- Index all `.liquid`, `.js`, `.mjs`, `.css`, `.scss`, `.json` files.
+- Inspect `assets/`, `locales/`, `config/`, `layout/`, `sections/`, `snippets/`, and `templates/`.
+
+2. Confirm the migration target with the developer.
+- Ask for `Component Type` (template, section, snippet, block).
+- Ask for `Component Name`.
+- Stop and request clarification if either is missing.
+
+3. Resolve dependencies recursively from the target component.
+- Follow Liquid dependencies (`render`, `include`, section/snippet usage, block references).
+- Follow JS module imports and runtime dependencies.
+- Follow CSS/SCSS dependencies required for correct rendering.
+- Collect localization keys used by the component tree.
+- Include static, private, and public theme blocks.
+- Continue traversal until no new dependencies are discovered.
+
+4. Build a migration bundle under `migration/`.
+- Output root: `migration/{component-name}/`
+- Include subfolders:
+  - `sections/`
+  - `snippets/`
+  - `assets/`
+  - `blocks/`
+  - `locales/`
+  - `templates/`
+  - `docs/`
+
+5. Apply naming and rewrite rules while copying files.
+- Prefix all new Liquid files with `td-`.
+- For private blocks that start with `_`, convert `_name` to `_td-name`.
+- If an import map is required, create `snippets/td-scripts.liquid`.
+- Prefix new asset filenames with `td-` and update all references/imports accordingly.
+
+6. Scope CSS for safe portability.
+- Scope rules with `td-` selectors to avoid collisions.
+- Use an existing `{% stylesheet %}` tag when present; do not add a second stylesheet tag.
+- Include only the minimum CSS required for component behavior.
+- Place shared/global dependency rules at the highest sensible level (Section > Snippet > Block).
+- Explicitly include rules that are not implicit globals (for example spacing or section-specific rules).
+- CSS variables that are dependant on theme settings should have a fallback value to the current theme's value
+
+7. Document migration requirements.
+- Create a dependency summary in `docs/`.
+- Document required theme settings, schema fields, and variable assumptions in `docs/`.
+- List any manual post-copy steps needed for the destination theme.
+
+## Output Contract
+
+Produce a complete folder bundle ready to copy into another theme, with renamed files, rewritten references, scoped styles, and docs for settings/variables required by the migrated component.

package/skills/horizon-component-migration/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Horizon Migration"
+  short_description: "Bundle Horizon components for migration to another theme"
+  default_prompt: "Use $horizon-component-migration to create a complete migration bundle for a Horizon component."