motion-ui-skill 2.0.0

package/agents/openai.yaml

@@ -0,0 +1,8 @@
+interface:
+  display_name: "Motion UI"
+  short_description: "Build polished, accessible web UI"
+  brand_color: "#6366F1"
+  default_prompt: "Use $motion-ui to build a polished, accessible web interface with the smallest suitable component set."
+
+policy:
+  allow_implicit_invocation: true

package/bin/index.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+/**
+ * Motion UI - Unified CLI
+ * Supports:
+ * - npx motion-ui-skill (auto-detects and installs skill)
+ * - motion-ui-skill update (checks upstream and updates skill)
+ * - motion-ui-skill search <query> (searches 339 components)
+ * - motion-ui-skill list [category] (lists components)
+ * - motion-ui-skill add <slug> (installs component into project)
+ */
+
+import { existsSync, readFileSync, mkdirSync, writeFileSync, lstatSync, realpathSync } from "fs";
+import { join, dirname, resolve, isAbsolute, sep } from "path";
+import { fileURLToPath } from "url";
+import { runInstaller } from "./installer.mjs";
+import { checkAndAutoUpdate, getLocalVersion } from "./updater.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const SKILL_ROOT = resolve(__dirname, "..");
+
+function loadCatalog() {
+  const catalogPath = join(SKILL_ROOT, "catalog.json");
+  if (!existsSync(catalogPath)) {
+    console.error("Error: catalog.json not found in " + SKILL_ROOT);
+    process.exit(1);
+  }
+  return JSON.parse(readFileSync(catalogPath, "utf-8"));
+}
+
+function printHelp() {
+  const version = getLocalVersion(SKILL_ROOT);
+  console.log(`
+Motion UI Skill CLI (v${version})
+Universal animated UI component library for React and Next.js.
+
+USAGE:
+  npx motion-ui-skill                 Auto-detect AI tools and install skill
+  motion-ui-skill <command> [options]
+
+COMMANDS:
+  install, setup        Auto-detect AI harnesses and install skill
+                        Flags: --all / -y, --global, --dry-run, --list
+  update                Check upstream for updates and auto-update
+                        Flags: --force, --silent
+  search <query>        Search 339 components by name, tag, or description
+  list [category]       List components (motion, agents, blocks, craft)
+  add <slug>            Install component files into your project
+                        Flags: --dest <dir> (default: ./src), --style <preset>
+
+OPTIONS:
+  -v, --version         Print version
+  -h, --help            Print help
+`);
+}
+
+function handleSearch(query) {
+  if (!query) {
+    console.log("Please specify a search term: motion-ui-skill search <query>");
+    return;
+  }
+  const catalog = loadCatalog();
+  const q = query.toLowerCase();
+  const matches = Object.values(catalog.components || {}).filter(
+    (c) =>
+      c.slug.toLowerCase().includes(q) ||
+      c.name.toLowerCase().includes(q) ||
+      c.description.toLowerCase().includes(q) ||
+      (c.category && c.category.toLowerCase().includes(q))
+  );
+
+  console.log(`\nFound ${matches.length} matching component(s):\n`);
+  for (const item of matches) {
+    const deps = item.dependencies?.length ? ` [deps: ${item.dependencies.join(", ")}]` : "";
+    console.log(`• \x1b[36m${item.name}\x1b[0m (\x1b[33m${item.slug}\x1b[0m) [${item.category}]${deps}`);
+    console.log(`  ${item.description}\n`);
+  }
+}
+
+function handleList(category) {
+  const catalog = loadCatalog();
+  const components = Object.values(catalog.components || {});
+  const filtered = category
+    ? components.filter((c) => c.category?.toLowerCase() === category.toLowerCase())
+    : components;
+
+  console.log(`\n📦 Motion UI Components (Total: ${filtered.length})\n`);
+  const categories = ["motion", "agents", "blocks", "craft"];
+
+  for (const cat of categories) {
+    const items = filtered.filter((c) => c.category === cat);
+    if (!items.length) continue;
+    console.log(`=== ${cat.toUpperCase()} (${items.length} components) ===`);
+    for (const item of items) {
+      console.log(`  • \x1b[33m${item.slug.padEnd(28)}\x1b[0m ${item.name}`);
+    }
+    console.log();
+  }
+}
+
+export function safePath(root, relative) {
+  if (typeof relative !== "string" || !relative || isAbsolute(relative)) {
+    throw new Error(`Path must stay relative to ${root}: ${relative}`);
+  }
+
+  const parts = relative.split(/[/\\]/);
+  if (parts.includes("..")) {
+    throw new Error(`Path must stay relative to ${root}: ${relative}`);
+  }
+
+  const resolvedRoot = resolve(root);
+  const target = resolve(resolvedRoot, ...parts);
+  if (target !== resolvedRoot && !target.startsWith(resolvedRoot + sep)) {
+    throw new Error(`Path escapes ${resolvedRoot}: ${relative}`);
+  }
+
+  let current = resolvedRoot;
+  for (const part of parts) {
+    current = join(current, part);
+    if (existsSync(current) && lstatSync(current).isSymbolicLink()) {
+      throw new Error(`Symlinks are not allowed in install paths: ${relative}`);
+    }
+  }
+  return target;
+}
+
+export function copyComponentFiles(comp, destDir, stylePreset = null) {
+  const files = [...(comp.component_files || []), ...(comp.util_files || [])];
+  if (stylePreset) {
+    if (!files.includes("lib/styles.ts")) files.push("lib/styles.ts");
+    if (!files.includes("lib/ease.ts")) files.push("lib/ease.ts");
+  }
+
+  const plan = files.map((rel) => {
+    const src = safePath(SKILL_ROOT, rel);
+    const dest = safePath(destDir, rel);
+    if (!existsSync(src) || !lstatSync(src).isFile()) {
+      throw new Error(`Required source file missing: ${src}`);
+    }
+    return { rel, src, dest };
+  });
+
+  for (const { src, dest } of plan) {
+    mkdirSync(dirname(dest), { recursive: true });
+    writeFileSync(dest, readFileSync(src));
+  }
+  return plan.map(({ rel }) => rel);
+}
+
+function handleAdd(slug, args) {
+  if (!slug) {
+    console.log("Please specify a component slug: motion-ui-skill add <slug>");
+    return;
+  }
+  const catalog = loadCatalog();
+  const comp = catalog.components?.[slug];
+  if (!comp) {
+    console.error(`Error: Component '${slug}' not found in catalog.`);
+    process.exit(1);
+  }
+
+  const destIdx = args.indexOf("--dest");
+  const destDir = resolve(destIdx !== -1 && args[destIdx + 1] ? args[destIdx + 1] : "./src");
+
+  console.log(`\n🚀 Installing \x1b[36m${comp.name}\x1b[0m (${slug}) into: ${destDir}\n`);
+
+  const styleIdx = args.indexOf("--style");
+  const stylePreset = styleIdx !== -1 ? args[styleIdx + 1] : null;
+  const validStyles = ["minimal", "origin", "enterprise", "glow", "ios", "brutalist"];
+  if (stylePreset && !validStyles.includes(stylePreset)) {
+    console.error(`Error: Unknown style preset '${stylePreset}'. Valid presets: ${validStyles.join(", ")}`);
+    process.exit(1);
+  }
+
+  for (const rel of copyComponentFiles(comp, destDir, stylePreset)) {
+    console.log(`  \x1b[32m✓\x1b[0m Copied ${rel}`);
+  }
+
+  if (stylePreset) {
+    console.log(`  \x1b[32m✓\x1b[0m Included style preset tokens for '${stylePreset}'`);
+  }
+
+  if (comp.dependencies?.length) {
+    console.log(`\n📦 Required dependencies:`);
+    console.log(`  npm install ${comp.dependencies.join(" ")}\n`);
+  }
+  console.log(`✨ Component '${slug}' installed successfully!\n`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (!command || command.startsWith("-")) {
+    if (args.includes("-v") || args.includes("--version")) {
+      console.log(`v${getLocalVersion(SKILL_ROOT)}`);
+      return;
+    }
+    if (args.includes("-h") || args.includes("--help")) {
+      printHelp();
+      return;
+    }
+    // Default action without arguments: Run the installer!
+    await runInstaller(args);
+    return;
+  }
+
+  switch (command) {
+    case "install":
+    case "setup":
+      await runInstaller(args.slice(1));
+      break;
+    case "update":
+    case "check-update": {
+      const force = args.includes("--force") || args.includes("-f");
+      const silent = args.includes("--silent") || args.includes("-s");
+      await checkAndAutoUpdate({ force, silent, skillRoot: SKILL_ROOT });
+      break;
+    }
+    case "search":
+      handleSearch(args[1]);
+      break;
+    case "list":
+      handleList(args[1]);
+      break;
+    case "add":
+    case "install-component":
+      handleAdd(args[1], args.slice(2));
+      break;
+    default:
+      printHelp();
+      break;
+  }
+}
+
+if (process.argv[1] && realpathSync(process.argv[1]) === __filename) {
+  main().catch((err) => {
+    console.error("Error:", err.message);
+    process.exit(1);
+  });
+}

package/bin/installer.mjs

@@ -0,0 +1,457 @@
+#!/usr/bin/env node
+
+/**
+ * Motion UI - Universal AI Harness Installer
+ * Auto-detects installed AI tools (Claude Code, Cursor, Windsurf, Codex,
+ * Antigravity, OpenCode, VS Code / Continue / Cline / Copilot) and sets up the
+ * Motion UI skill and rules seamlessly.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync } from "fs";
+import { createInterface } from "readline";
+import { homedir, platform } from "os";
+import { join, dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const SKILL_ROOT = resolve(__dirname, "..");
+
+const COLORS = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+  red: "\x1b[31m",
+};
+
+const c = (color, text) => `${COLORS[color]}${text}${COLORS.reset}`;
+
+// Files and directories to copy when installing the skill
+const SKILL_COPY_ITEMS = [
+  "SKILL.md",
+  "catalog.json",
+  "package.json",
+  "agents",
+  "bin",
+  "components",
+  "lib",
+  "references",
+  "scripts",
+];
+
+/**
+ * Safely copy the skill package into the target directory.
+ */
+export function copySkillPackage(targetDir, options = {}) {
+  const { dryRun = false, copiedDirs } = options;
+  if (dryRun) return;
+
+  const resolvedTarget = resolve(targetDir);
+  if (copiedDirs) {
+    if (copiedDirs.has(resolvedTarget)) {
+      return;
+    }
+    copiedDirs.add(resolvedTarget);
+  }
+
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  for (const item of SKILL_COPY_ITEMS) {
+    const src = join(SKILL_ROOT, item);
+    const dest = join(targetDir, item);
+    if (existsSync(src)) {
+      cpSync(src, dest, {
+        recursive: true,
+        filter: (srcPath) => {
+          const base = srcPath.split(/[/\\]/).pop();
+          return !["node_modules", ".git", ".last_update_check", "__pycache__"].includes(base);
+        },
+      });
+    }
+  }
+}
+
+/**
+ * Append or update a rule section in a text/markdown file.
+ */
+export function upsertRuleContent(filePath, marker, content, options = {}) {
+  const { dryRun = false } = options;
+  if (dryRun) return;
+
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  let existing = "";
+  if (existsSync(filePath)) {
+    existing = readFileSync(filePath, "utf-8");
+  }
+
+  const startMarker = `<!-- BEGIN ${marker} -->`;
+  const endMarker = `<!-- END ${marker} -->`;
+  const block = `${startMarker}\n${content.trim()}\n${endMarker}\n`;
+
+  if (existing.includes(startMarker) && existing.includes(endMarker)) {
+    const regex = new RegExp(`${startMarker}[\\s\\S]*?${endMarker}\\n?`, "g");
+    existing = existing.replace(regex, block);
+  } else {
+    existing = existing.trimEnd() ? `${existing.trimEnd()}\n\n${block}` : block;
+  }
+
+  writeFileSync(filePath, existing);
+}
+
+// ── AI Harness Definitions ──
+
+export const AI_HARNESSES = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    detect: (cwd = process.cwd()) => {
+      return (
+        existsSync(join(homedir(), ".claude.json")) ||
+        existsSync(join(homedir(), ".claude")) ||
+        existsSync(join(cwd, "CLAUDE.md")) ||
+        existsSync(join(cwd, ".claude"))
+      );
+    },
+    installProject: (cwd, opts) => {
+      const skillDest = join(cwd, ".agents", "skills", "motion-ui");
+      copySkillPackage(skillDest, opts);
+
+      const claudeMd = join(cwd, "CLAUDE.md");
+      const rule = [
+        "## Motion UI Skill",
+        "- For high-performance animated UI components and design systems, reference `.agents/skills/motion-ui/SKILL.md`.",
+        "- On skill activation, run: `node .agents/skills/motion-ui/bin/updater.mjs --silent` to ensure components and physics tokens are up to date.",
+        "- Follow `.agents/skills/motion-ui/catalog.json` for component source files and dependencies.",
+      ].join("\n");
+      upsertRuleContent(claudeMd, "MOTION_UI_SKILL", rule, opts);
+      return [skillDest, claudeMd];
+    },
+    installGlobal: (opts) => {
+      const globalSkill = join(homedir(), ".claude", "skills", "motion-ui");
+      copySkillPackage(globalSkill, opts);
+      return [globalSkill];
+    },
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    detect: (cwd = process.cwd()) => {
+      return (
+        existsSync(join(homedir(), ".cursor")) ||
+        existsSync(join(cwd, ".cursor")) ||
+        existsSync(join(cwd, ".cursorrules")) ||
+        (platform() === "darwin" && existsSync("/Applications/Cursor.app"))
+      );
+    },
+    installProject: (cwd, opts) => {
+      const skillDest = join(cwd, ".agents", "skills", "motion-ui");
+      copySkillPackage(skillDest, opts);
+
+      const ruleFile = join(cwd, ".cursor", "rules", "motion-ui.mdc");
+      const ruleMdc = [
+        "---",
+        "description: Motion UI animated components library and design system",
+        "globs: **/*.{tsx,jsx,ts,js,css}",
+        "alwaysApply: false",
+        "---",
+        "",
+        "# Motion UI Integration",
+        "",
+        "When building animated UI components, widgets, or craft surfaces:",
+        "1. Check for latest skill version before activation: `node .agents/skills/motion-ui/bin/updater.mjs --silent`.",
+        "2. Consult `.agents/skills/motion-ui/SKILL.md` and `.agents/skills/motion-ui/catalog.json`.",
+        "3. Provide required component source code and shared utilities (`@/lib/styles`, `@/lib/ease`, `@/lib/utils`, `@/lib/hooks/*`).",
+        "4. Follow the 6 style presets (minimal, origin, enterprise, glow, ios, brutalist) as defined in `lib/styles.ts`.",
+      ].join("\n");
+
+      if (!opts.dryRun) {
+        mkdirSync(dirname(ruleFile), { recursive: true });
+        writeFileSync(ruleFile, ruleMdc + "\n");
+      }
+      return [skillDest, ruleFile];
+    },
+    installGlobal: (opts) => {
+      const globalDest = join(homedir(), ".cursor", "skills", "motion-ui");
+      copySkillPackage(globalDest, opts);
+      return [globalDest];
+    },
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    detect: (cwd = process.cwd()) => {
+      return (
+        existsSync(join(homedir(), ".codeium", "windsurf")) ||
+        existsSync(join(homedir(), ".windsurf")) ||
+        existsSync(join(cwd, ".windsurf")) ||
+        existsSync(join(cwd, ".windsurfrules")) ||
+        (platform() === "darwin" && existsSync("/Applications/Windsurf.app"))
+      );
+    },
+    installProject: (cwd, opts) => {
+      const skillDest = join(cwd, ".agents", "skills", "motion-ui");
+      copySkillPackage(skillDest, opts);
+
+      const rulesFile = join(cwd, ".windsurf", "rules", "motion-ui.md");
+      const ruleContent = [
+        "# Motion UI Rules",
+        "When user asks for animations or UI components:",
+        "- Check for updates: `node .agents/skills/motion-ui/bin/updater.mjs --silent`",
+        "- Consult `.agents/skills/motion-ui/SKILL.md`",
+        "- Include required shared utilities from `lib/` and respect reduced-motion preferences.",
+      ].join("\n");
+
+      if (!opts.dryRun) {
+        mkdirSync(dirname(rulesFile), { recursive: true });
+        writeFileSync(rulesFile, ruleContent + "\n");
+      }
+      return [skillDest, rulesFile];
+    },
+    installGlobal: (opts) => {
+      const globalDest = join(homedir(), ".codeium", "windsurf", "skills", "motion-ui");
+      copySkillPackage(globalDest, opts);
+      return [globalDest];
+    },
+  },
+  {
+    id: "codex",
+    name: "Codex (CLI + App)",
+    detect: (cwd = process.cwd()) => {
+      return (
+        existsSync(join(homedir(), ".codex")) ||
+        existsSync(join(cwd, ".codex")) ||
+        existsSync(join(cwd, "agents", "openai.yaml"))
+      );
+    },
+    installProject: (cwd, opts) => {
+      const skillDest = join(cwd, ".agents", "skills", "motion-ui");
+      copySkillPackage(skillDest, opts);
+      return [skillDest];
+    },
+    installGlobal: (opts) => {
+      const globalDest = join(homedir(), ".codex", "skills", "motion-ui");
+      copySkillPackage(globalDest, opts);
+      return [globalDest];
+    },
+  },
+  {
+    id: "antigravity",
+    name: "Antigravity",
+    detect: (cwd = process.cwd()) => {
+      return (
+        existsSync(join(homedir(), ".gemini", "antigravity")) ||
+        existsSync(join(homedir(), ".config", "antigravity")) ||
+        existsSync(join(cwd, ".agents"))
+      );
+    },
+    installProject: (cwd, opts) => {
+      const skillDest = join(cwd, ".agents", "skills", "motion-ui");
+      copySkillPackage(skillDest, opts);
+      return [skillDest];
+    },
+    installGlobal: (opts) => {
+      const globalDest = join(homedir(), ".gemini", "antigravity", "skills", "motion-ui");
+      copySkillPackage(globalDest, opts);
+      return [globalDest];
+    },
+  },
+  {
+    id: "opencode",
+    name: "OpenCode",
+    detect: (cwd = process.cwd()) => {
+      return (
+        existsSync(join(homedir(), ".config", "opencode")) ||
+        existsSync(join(cwd, "opencode.json")) ||
+        existsSync(join(cwd, ".opencode"))
+      );
+    },
+    installProject: (cwd, opts) => {
+      const skillDest = join(cwd, ".opencode", "skills", "motion-ui");
+      copySkillPackage(skillDest, opts);
+      return [skillDest];
+    },
+    installGlobal: (opts) => {
+      const globalDest = join(homedir(), ".config", "opencode", "skills", "motion-ui");
+      copySkillPackage(globalDest, opts);
+      return [globalDest];
+    },
+  },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    detect: (cwd = process.cwd()) => {
+      return (
+        existsSync(join(cwd, ".github")) ||
+        existsSync(join(cwd, ".vscode")) ||
+        existsSync(join(homedir(), ".config", "github-copilot"))
+      );
+    },
+    installProject: (cwd, opts) => {
+      const skillDest = join(cwd, ".agents", "skills", "motion-ui");
+      copySkillPackage(skillDest, opts);
+
+      const copilotFile = join(cwd, ".github", "copilot-instructions.md");
+      const rule = [
+        "## Motion UI Skill Integration",
+        "Use the Motion UI skill located at `.agents/skills/motion-ui/SKILL.md` for animated components.",
+        "On activation, check version: `node .agents/skills/motion-ui/bin/updater.mjs --silent`.",
+      ].join("\n");
+      upsertRuleContent(copilotFile, "MOTION_UI_SKILL", rule, opts);
+      return [skillDest, copilotFile];
+    },
+    installGlobal: () => [],
+  },
+  {
+    id: "cline-roo",
+    name: "Cline & Roo Code",
+    detect: (cwd = process.cwd()) => {
+      return (
+        existsSync(join(cwd, ".clinerules")) ||
+        existsSync(join(cwd, ".roomodes")) ||
+        existsSync(join(cwd, ".roo"))
+      );
+    },
+    installProject: (cwd, opts) => {
+      const skillDest = join(cwd, ".agents", "skills", "motion-ui");
+      copySkillPackage(skillDest, opts);
+
+      const clineFile = join(cwd, ".clinerules");
+      const rule = [
+        "## Motion UI Animated Components",
+        "- Skill instructions and catalog: `.agents/skills/motion-ui/SKILL.md`",
+        "- Check for updates before activation: `node .agents/skills/motion-ui/bin/updater.mjs --silent`",
+      ].join("\n");
+      upsertRuleContent(clineFile, "MOTION_UI_SKILL", rule, opts);
+      return [skillDest, clineFile];
+    },
+    installGlobal: () => [],
+  },
+];
+
+function ask(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Main interactive installer entrypoint.
+ */
+export async function runInstaller(args = []) {
+  const cwd = process.cwd();
+  const isGlobal = args.includes("--global");
+  const isAll = args.includes("--all") || args.includes("-y") || args.includes("--yes");
+  const isDryRun = args.includes("--dry-run");
+  const isList = args.includes("--list");
+
+  console.log();
+  console.log(c("bold", "  ┌──────────────────────────────────────────────┐"));
+  console.log(
+    c("bold", "  │") +
+      c("cyan", "  motion-ui") +
+      c("dim", " — AI Agent Skill Auto-Installer  ") +
+      c("bold", "│")
+  );
+  console.log(c("bold", "  └──────────────────────────────────────────────┘"));
+  console.log();
+
+  console.log(c("bold", "  Detecting AI harnesses..."));
+  console.log();
+
+  const detected = AI_HARNESSES.filter((h) => {
+    try {
+      return h.detect(cwd);
+    } catch {
+      return false;
+    }
+  });
+
+  if (detected.length === 0) {
+    console.log(c("yellow", "  No specific AI harnesses detected in current workspace."));
+    console.log(c("dim", "  Installing to universal standard: .agents/skills/motion-ui/"));
+    console.log();
+    const defaultDest = join(cwd, ".agents", "skills", "motion-ui");
+    if (!isDryRun) {
+      copySkillPackage(defaultDest);
+      console.log(c("green", "  ✓ Universal Skill") + c("dim", ` → ${defaultDest}`));
+    }
+    return;
+  }
+
+  for (let i = 0; i < detected.length; i++) {
+    console.log(c("green", `  [${i + 1}] ✓ ${detected[i].name}`));
+  }
+  console.log();
+
+  if (isList) {
+    return;
+  }
+
+  let selected = detected;
+
+  if (!isAll && process.stdin.isTTY) {
+    const prompt = c("bold", `  Install to all ${detected.length} detected harnesses? [Y/n] `);
+    const answer = await ask(prompt);
+    if (answer && answer.toLowerCase().startsWith("n")) {
+      const selectAnswer = await ask(c("bold", "  Enter numbers to install (e.g. 1, 3): "));
+      const indices = selectAnswer
+        .split(",")
+        .map((s) => parseInt(s.trim(), 10) - 1)
+        .filter((idx) => idx >= 0 && idx < detected.length);
+      if (indices.length > 0) {
+        selected = indices.map((idx) => detected[idx]);
+      }
+    }
+  }
+
+  console.log(c("bold", `  Installing Motion UI skill (${isGlobal ? "global" : "project-scoped"})...`));
+  console.log();
+
+  const copiedDirs = new Set();
+  const installOpts = { dryRun: isDryRun, copiedDirs };
+  const installedPaths = [];
+  for (const tool of selected) {
+    try {
+      const paths = isGlobal ? tool.installGlobal(installOpts) : tool.installProject(cwd, installOpts);
+      for (const p of paths) {
+        console.log(c("green", `  ✓ ${tool.name}`) + c("dim", ` → ${p}`));
+        installedPaths.push(p);
+      }
+    } catch (err) {
+      console.log(c("red", `  ✗ ${tool.name}: ${err.message}`));
+    }
+  }
+
+  console.log();
+  console.log(c("bold", "  🎉 Done! Motion UI is installed and configured."));
+  console.log();
+  console.log(c("dim", "  • Auto-update check is enabled on skill activation."));
+  console.log(c("dim", "  • 339 animated components and 6 style presets ready."));
+  console.log(c("dim", "  • Run manually anytime: node .agents/skills/motion-ui/bin/updater.mjs"));
+  console.log();
+  console.log(c("cyan", "  Just ask your agent:") + c("bold", ' "Build an animated card using motion-ui"'));
+  console.log();
+}
+
+if (process.argv[1] === __filename) {
+  runInstaller(process.argv.slice(2)).catch((err) => {
+    console.error(c("red", `\nInstaller error: ${err.message}\n`));
+    process.exit(1);
+  });
+}