kinetik-ui 0.0.1 → 1.0.0

package/dist/index.js

@@ -0,0 +1,1356 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../mcp/dist/index.js
+var require_dist = __commonJS({
+  "../mcp/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.INSTRUCTIONS = void 0;
+    exports2.scoreItem = scoreItem;
+    exports2.installPlan = installPlan;
+    exports2.createServer = createServer;
+    exports2.startStdioServer = startStdioServer;
+    var mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+    var stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+    var zod_1 = require("zod");
+    var CATEGORIES = [
+      "background",
+      "card",
+      "interaction",
+      "text",
+      "navigation",
+      "feedback",
+      "data",
+      "screen"
+    ];
+    exports2.INSTRUCTIONS = `Kinetik UI is a library of motion and effect components for Expo / React Native (Reanimated 4, Gesture Handler, Skia). Components are copied into the user's project as source with the kinetik-ui CLI, which installs dependencies with \`npx expo install\` so native versions match the Expo SDK.
+
+Guidelines when building with Kinetik:
+- Find components with search_components or list_components, read one with get_component, and install with the commands from get_install_plan. Do not hand-copy files when the CLI is available.
+- Requires the React Native New Architecture (Reanimated 4). Gesture-driven components need the app wrapped in <GestureHandlerRootView style={{ flex: 1 }}>.
+- Use colours, spacing and type from useKinetikTheme() (see get_tokens); do not hard-code colours.
+- Every component supports reduced motion; keep that behaviour when editing copied files.
+- Prefer one expressive component per screen; motion should explain, not decorate.`;
+    var text = (value) => ({
+      content: [
+        {
+          type: "text",
+          text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+        }
+      ]
+    });
+    function summary(item) {
+      return {
+        name: item.name,
+        kind: item.meta?.kind,
+        title: item.title,
+        description: item.description,
+        category: item.meta?.category ?? item.categories?.[0],
+        web: item.meta?.web,
+        version: item.meta?.version
+      };
+    }
+    function scoreItem(item, query) {
+      const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+      let total = 0;
+      for (const term of terms) {
+        const fields = [
+          [item.name.toLowerCase(), 6],
+          [(item.title ?? "").toLowerCase(), 5],
+          [(item.meta?.category ?? "").toLowerCase(), 3],
+          [(item.description ?? "").toLowerCase(), 2],
+          [(item.meta?.guide ?? "").toLowerCase(), 1]
+        ];
+        const hit = fields.find(([field]) => field.includes(term));
+        if (!hit)
+          return 0;
+        total += hit[1] + (item.name === term ? 4 : 0);
+      }
+      return total;
+    }
+    var PACKAGE_SPEC2 = /^(@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*(@[a-z0-9.^~*+-]+)?$/;
+    var ITEM_NAME2 = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+    async function installPlan(registry, names, installed = {}) {
+      const badName = names.find((n) => !ITEM_NAME2.test(n));
+      if (badName)
+        throw new Error(`"${badName}" is not a valid component name.`);
+      const items = await registry.resolve(names);
+      const components = items.filter((i) => i.meta?.kind !== "shared");
+      const dependencies = [...new Set(items.flatMap((i) => i.dependencies ?? []))].sort();
+      const badDep = dependencies.find((d) => !PACKAGE_SPEC2.test(d));
+      if (badDep)
+        throw new Error(`The registry declares an invalid package name: ${JSON.stringify(badDep)}`);
+      const missing = names.filter((n) => !installed[n]);
+      const needsInit = Object.keys(installed).length === 0;
+      const notes = [];
+      if (dependencies.includes("react-native-gesture-handler")) {
+        notes.push("Wrap the app root in <GestureHandlerRootView style={{ flex: 1 }}> (react-native-gesture-handler).");
+      }
+      if (dependencies.includes("@shopify/react-native-skia")) {
+        notes.push("Uses Skia: needs a development build (not Expo Go on all SDKs); on the web, load CanvasKit before rendering.");
+      }
+      if (dependencies.includes("react-native-safe-area-context")) {
+        notes.push("Render inside a <SafeAreaProvider> (expo-router apps already have one).");
+      }
+      if (names.includes("morph-sheet")) {
+        notes.push("MorphSheet wraps the screen it covers: pass the screen as children so Android can blur it.");
+      }
+      notes.push("Optional: wrap the app in <KinetikProvider> to force a scheme, brand colours or turn off haptics.");
+      return {
+        commands: [
+          ...needsInit ? ["npx kinetik-ui init"] : [],
+          `npx kinetik-ui add ${(missing.length ? missing : names).join(" ")}`
+        ],
+        alreadyInstalled: names.filter((n) => installed[n]),
+        dependencies,
+        expoInstall: dependencies.length ? `npx expo install ${dependencies.join(" ")}` : null,
+        files: items.flatMap((i) => i.files.map((f) => ({ item: i.name, target: f.target }))),
+        components: components.map(summary),
+        notes
+      };
+    }
+    function createServer({ registry, installed, version = "0.1.0" }) {
+      const server = new mcp_js_1.McpServer({ name: "kinetik-ui", version }, { instructions: exports2.INSTRUCTIONS });
+      const components = async () => (await registry.index()).items.filter((i) => i.meta?.kind !== "shared");
+      server.registerTool("list_components", {
+        title: "List Kinetik components",
+        description: 'Lists every Kinetik UI component and screen template (category "screen") with a one-line description.',
+        inputSchema: { category: zod_1.z.enum(CATEGORIES).optional().describe("Only this category") },
+        annotations: { readOnlyHint: true }
+      }, async ({ category }) => {
+        const all = await components();
+        return text(all.filter((c2) => !category || c2.meta?.category === category).map(summary));
+      });
+      server.registerTool("search_components", {
+        title: "Search Kinetik components",
+        description: 'Finds components by name, category or what they do (e.g. "swipe cards", "loading").',
+        inputSchema: { query: zod_1.z.string().min(1).describe("Words describing the component you need") },
+        annotations: { readOnlyHint: true }
+      }, async ({ query }) => {
+        const hits = (await components()).map((item) => ({ item, s: scoreItem(item, query) })).filter((r) => r.s > 0).sort((a, b) => b.s - a.s).map((r) => summary(r.item));
+        return text(hits.length ? hits : `No components match "${query}". Try list_components.`);
+      });
+      server.registerTool("get_component", {
+        title: "Get a Kinetik component",
+        description: "Returns a component's usage guide, accessibility and performance notes, dependencies and full source files.",
+        inputSchema: {
+          name: zod_1.z.string().describe('Component name, e.g. "glint-card"'),
+          includeSource: zod_1.z.boolean().default(true).describe("Include file contents")
+        },
+        annotations: { readOnlyHint: true }
+      }, async ({ name, includeSource }) => {
+        const item = await registry.item(name);
+        const closure = await registry.resolve([name]);
+        return text({
+          ...summary(item),
+          dependencies: item.dependencies ?? [],
+          registryDependencies: closure.filter((i) => i.name !== name).map((i) => i.name),
+          guide: item.meta?.guide,
+          accessibility: item.meta?.a11y,
+          performance: item.meta?.perf,
+          files: item.files.map((f) => ({
+            target: f.target,
+            ...includeSource ? { content: f.content } : null
+          }))
+        });
+      });
+      server.registerTool("get_install_plan", {
+        title: "Plan a Kinetik install",
+        description: "Returns the commands to add components to an Expo project, the dependencies they bring and setup notes.",
+        inputSchema: {
+          components: zod_1.z.array(zod_1.z.string()).min(1).describe("Component names to install")
+        },
+        annotations: { readOnlyHint: true }
+      }, async ({ components: names }) => text(await installPlan(registry, names, await installed?.() ?? {})));
+      server.registerTool("get_tokens", {
+        title: "Get Kinetik design tokens",
+        description: "Returns the token and motion source: palettes (dark/light), spacing, radius, type, shadows, springs and durations.",
+        annotations: { readOnlyHint: true }
+      }, async () => {
+        const [tokens, motion] = await Promise.all([
+          registry.item("kinetik-tokens"),
+          registry.item("kinetik-motion")
+        ]);
+        return text({
+          usage: "Read values with useKinetikTheme(); pick motion with spring(name, reduced) and timing(name, reduced).",
+          files: [...tokens.files, ...motion.files].map((f) => ({
+            target: f.target,
+            content: f.content
+          }))
+        });
+      });
+      return server;
+    }
+    async function startStdioServer(options) {
+      const server = createServer(options);
+      await server.connect(new stdio_js_1.StdioServerTransport());
+    }
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "kinetik-ui",
+      version: "1.0.0",
+      description: "Add Kinetik UI motion components to an Expo project: copies the source, installs SDK-compatible dependencies, and serves the registry to AI agents over MCP.",
+      license: "MIT",
+      homepage: "https://kinetik-ui.dev",
+      repository: {
+        type: "git",
+        url: "git+https://github.com/NURULLAHTURGUT/kinetikui.git",
+        directory: "packages/cli"
+      },
+      bugs: {
+        url: "https://github.com/NURULLAHTURGUT/kinetikui/issues"
+      },
+      bin: {
+        "kinetik-ui": "dist/index.js",
+        kinetik: "dist/index.js"
+      },
+      files: [
+        "dist"
+      ],
+      engines: {
+        node: ">=20.19"
+      },
+      keywords: [
+        "expo",
+        "react-native",
+        "reanimated",
+        "skia",
+        "animation",
+        "components",
+        "shadcn",
+        "registry",
+        "mcp",
+        "ai"
+      ],
+      scripts: {
+        build: "tsc --noEmit -p tsconfig.build.json && node build.mjs",
+        typecheck: "tsc --noEmit",
+        test: 'node --import tsx --test "src/**/*.test.ts"',
+        prepublishOnly: "pnpm build && pnpm test"
+      },
+      dependencies: {
+        "@modelcontextprotocol/sdk": "^1.32.1",
+        zod: "^4.6.5"
+      },
+      devDependencies: {
+        "@kinetik/mcp": "workspace:*",
+        "@types/node": "^22.15.0",
+        esbuild: "0.28.2",
+        tsx: "^4.23.15",
+        typescript: "~6.0.3"
+      }
+    };
+  }
+});
+
+// src/index.ts
+var import_node_util = require("node:util");
+
+// src/install.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path5 = __toESM(require("node:path"));
+
+// src/project.ts
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path3 = __toESM(require("node:path"));
+
+// src/registry.ts
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_path2 = __toESM(require("node:path"));
+
+// src/safety.ts
+var import_node_path = __toESM(require("node:path"));
+
+// src/ui.ts
+var enabled = process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+var wrap = (open, close) => (s) => enabled ? `\x1B[${open}m${s}\x1B[${close}m` : s;
+var c = {
+  bold: wrap(1, 22),
+  dim: wrap(2, 22),
+  red: wrap(31, 39),
+  green: wrap(32, 39),
+  yellow: wrap(33, 39),
+  cyan: wrap(36, 39),
+  ember: (s) => enabled ? `\x1B[38;2;255;106;61m${s}\x1B[39m` : s
+};
+var log = {
+  info: (msg) => console.log(msg),
+  step: (msg) => console.log(`${c.ember("\u203A")} ${msg}`),
+  success: (msg) => console.log(`${c.green("\u2714")} ${msg}`),
+  warn: (msg) => console.warn(`${c.yellow("!")} ${msg}`),
+  error: (msg) => console.error(`${c.red("\u2716")} ${msg}`),
+  blank: () => console.log("")
+};
+var CliError = class extends Error {
+  constructor(message, hint) {
+    super(message);
+    this.hint = hint;
+  }
+  hint;
+};
+
+// src/safety.ts
+var PACKAGE_SPEC = /^(@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*(@[a-z0-9.^~*+-]+)?$/;
+var ITEM_NAME = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+function isPackageSpec(value) {
+  return value.length <= 214 && PACKAGE_SPEC.test(value);
+}
+function isItemName(value) {
+  return value.length <= 100 && ITEM_NAME.test(value);
+}
+function assertItemName(name) {
+  if (!isItemName(name)) {
+    throw new CliError(
+      `"${name}" is not a valid component name.`,
+      "Names are lowercase words joined by hyphens, like glint-card."
+    );
+  }
+  return name;
+}
+function assertPackageSpecs(specs, source) {
+  const bad = specs.filter((s) => !isPackageSpec(s));
+  if (bad.length > 0) {
+    throw new CliError(
+      `${source} declares a dependency that is not a valid npm package name: ${bad.map((b) => JSON.stringify(b)).join(", ")}`,
+      "Nothing was installed. If you use a custom --registry, check that it is one you trust."
+    );
+  }
+  return specs;
+}
+function resolveInside(root, rel) {
+  const base = import_node_path.default.resolve(root);
+  if (rel.includes("\0") || import_node_path.default.isAbsolute(rel) || /^[a-zA-Z]:/.test(rel)) {
+    throw outside(rel);
+  }
+  const abs = import_node_path.default.resolve(base, rel);
+  const relative = import_node_path.default.relative(base, abs);
+  if (relative === "" || relative.startsWith("..") || import_node_path.default.isAbsolute(relative)) {
+    throw outside(rel);
+  }
+  return abs;
+}
+function outside(rel) {
+  return new CliError(
+    `Refusing to write outside the project: ${JSON.stringify(rel)}`,
+    "A registry file targets a path outside your project. Nothing was written."
+  );
+}
+
+// src/registry.ts
+var DEFAULT_REGISTRY = "https://kinetik-ui.dev/r";
+var Registry = class {
+  constructor(base) {
+    this.base = base;
+  }
+  base;
+  cache = /* @__PURE__ */ new Map();
+  isRemote() {
+    return /^https?:\/\//.test(this.base);
+  }
+  async read(file) {
+    if (this.isRemote()) {
+      const url = `${this.base.replace(/\/$/, "")}/${file}`;
+      let res;
+      try {
+        res = await fetch(url, { headers: { accept: "application/json" } });
+      } catch (error) {
+        throw new CliError(
+          `Could not reach the registry at ${url}`,
+          `Check your connection or pass --registry. (${String(error)})`
+        );
+      }
+      if (res.status === 404) throw new CliError(`Not found in registry: ${url}`);
+      if (!res.ok) throw new CliError(`Registry request failed (${res.status}) for ${url}`);
+      return res.json();
+    }
+    const full = import_node_path2.default.resolve(this.base, file);
+    try {
+      return JSON.parse(await import_promises.default.readFile(full, "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        throw new CliError(`Not found in registry: ${full}`);
+      throw error;
+    }
+  }
+  index() {
+    return this.read("registry.json");
+  }
+  item(name) {
+    try {
+      assertItemName(name);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    let pending = this.cache.get(name);
+    if (!pending) {
+      pending = this.read(`${name}.json`);
+      this.cache.set(name, pending);
+    }
+    return pending;
+  }
+  /** The item and everything it depends on, dependencies first. */
+  async resolve(names) {
+    const seen = /* @__PURE__ */ new Set();
+    const order = [];
+    const visit = async (name) => {
+      if (seen.has(name)) return;
+      seen.add(name);
+      const item = await this.item(name);
+      for (const dep of item.registryDependencies ?? []) await visit(dependencyName(dep));
+      order.push(item);
+    };
+    for (const name of names) await visit(name);
+    return order;
+  }
+};
+function dependencyName(ref) {
+  const base = ref.split("/").pop() ?? ref;
+  return base.replace(/\.json$/, "");
+}
+
+// src/project.ts
+var CONFIG_FILE = "kinetik.json";
+function findProject(cwd) {
+  let dir = import_node_path3.default.resolve(cwd);
+  for (; ; ) {
+    const pkgFile = import_node_path3.default.join(dir, "package.json");
+    if (import_node_fs.default.existsSync(pkgFile)) {
+      const pkg = JSON.parse(import_node_fs.default.readFileSync(pkgFile, "utf8"));
+      return { root: dir, pkg, config: readConfig(dir) };
+    }
+    const parent = import_node_path3.default.dirname(dir);
+    if (parent === dir) {
+      throw new CliError("No package.json found.", "Run this inside an Expo project.");
+    }
+    dir = parent;
+  }
+}
+function readConfig(root) {
+  const file = import_node_path3.default.join(root, CONFIG_FILE);
+  if (!import_node_fs.default.existsSync(file)) return null;
+  try {
+    const raw = JSON.parse(import_node_fs.default.readFileSync(file, "utf8"));
+    return {
+      registry: raw.registry ?? DEFAULT_REGISTRY,
+      componentsDir: raw.componentsDir ?? "components/kinetik",
+      libDir: raw.libDir ?? "lib/kinetik",
+      installed: raw.installed ?? {},
+      ...raw.$schema ? { $schema: raw.$schema } : null
+    };
+  } catch {
+    throw new CliError(`${CONFIG_FILE} is not valid JSON.`);
+  }
+}
+function writeConfig(root, config) {
+  const ordered = {
+    $schema: config.$schema,
+    registry: config.registry,
+    componentsDir: config.componentsDir,
+    libDir: config.libDir,
+    installed: Object.fromEntries(
+      Object.entries(config.installed).sort(([a], [b]) => a.localeCompare(b))
+    )
+  };
+  import_node_fs.default.writeFileSync(import_node_path3.default.join(root, CONFIG_FILE), `${JSON.stringify(ordered, null, 2)}
+`);
+}
+function defaultLayout(root) {
+  const useSrc = import_node_fs.default.existsSync(import_node_path3.default.join(root, "src"));
+  const base = useSrc ? "src/" : "";
+  return { componentsDir: `${base}components/kinetik`, libDir: `${base}lib/kinetik` };
+}
+function dependencyVersion(pkg, name) {
+  return pkg.dependencies?.[name] ?? pkg.devDependencies?.[name];
+}
+function installedVersion(root, name) {
+  try {
+    const file = require.resolve(`${name}/package.json`, { paths: [root] });
+    return JSON.parse(import_node_fs.default.readFileSync(file, "utf8")).version;
+  } catch {
+    return void 0;
+  }
+}
+function major(version) {
+  const m = version ? /(\d+)\./.exec(version) : null;
+  return m?.[1] ? Number(m[1]) : void 0;
+}
+
+// src/transform.ts
+var import_node_path4 = __toESM(require("node:path"));
+var DEFAULT_PREFIXES = {
+  components: "~/components/kinetik",
+  lib: "~/lib/kinetik"
+};
+var posix = import_node_path4.default.posix;
+function mapTarget(target, layout) {
+  if (target.startsWith(`${DEFAULT_PREFIXES.components}/`)) {
+    return posix.join(
+      toPosix(layout.componentsDir),
+      target.slice(DEFAULT_PREFIXES.components.length + 1)
+    );
+  }
+  if (target.startsWith(`${DEFAULT_PREFIXES.lib}/`)) {
+    return posix.join(toPosix(layout.libDir), target.slice(DEFAULT_PREFIXES.lib.length + 1));
+  }
+  if (target.startsWith("~/")) return target.slice(2);
+  return target;
+}
+var IMPORT_RE = /(\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*|^\s*import\s+)(['"])(\.{1,2}\/[^'"]*)\2/gm;
+var EXT_RE = /\.(tsx?|jsx?)$/;
+function rewriteImports(content, fileTarget, layout, knownTargets) {
+  const fromMapped = mapTarget(fileTarget, layout);
+  const known = new Map(knownTargets.map((t) => [t.replace(EXT_RE, ""), t]));
+  return content.replace(IMPORT_RE, (match, prefix, quote, spec) => {
+    const resolved = posix.normalize(posix.join(posix.dirname(fileTarget), spec));
+    const target = known.get(resolved) ?? known.get(`${resolved}/index`);
+    if (!target) return match;
+    let rel = posix.relative(posix.dirname(fromMapped), mapTarget(target, layout)).replace(EXT_RE, "");
+    if (!rel.startsWith(".")) rel = `./${rel}`;
+    return `${prefix}${quote}${rel}${quote}`;
+  });
+}
+function toPosix(p) {
+  return p.split(import_node_path4.default.sep).join("/").replace(/^\.\//, "").replace(/\/$/, "");
+}
+
+// src/install.ts
+function planInstall(project, config, items) {
+  const knownTargets = items.flatMap((i) => i.files.map((f) => f.target));
+  const files = [];
+  for (const item of items) {
+    assertPackageSpecs(item.dependencies ?? [], `Registry item "${item.name}"`);
+    for (const file of item.files) {
+      if (file.content === void 0)
+        throw new CliError(`Registry item "${item.name}" has no file contents for ${file.path}.`);
+      const rel = mapTarget(file.target, config);
+      const content = rewriteImports(file.content, file.target, config, knownTargets);
+      const abs = resolveInside(project.root, rel);
+      let status = "create";
+      if (import_node_fs2.default.existsSync(abs)) {
+        status = normalize(import_node_fs2.default.readFileSync(abs, "utf8")) === normalize(content) ? "identical" : "conflict";
+      }
+      files.push({ item: item.name, path: rel, content, status });
+    }
+  }
+  const dependencies = [...new Set(items.flatMap((i) => i.dependencies ?? []))].sort();
+  const missingDependencies = dependencies.filter((d) => !dependencyVersion(project.pkg, d));
+  return { files, dependencies, missingDependencies };
+}
+var normalize = (s) => s.replace(/\r\n/g, "\n");
+function writeFiles(project, files, overwrite) {
+  const written = [];
+  for (const file of files) {
+    if (file.status === "identical") continue;
+    if (file.status === "conflict" && !overwrite) continue;
+    const abs = resolveInside(project.root, file.path);
+    import_node_fs2.default.mkdirSync(import_node_path5.default.dirname(abs), { recursive: true });
+    import_node_fs2.default.writeFileSync(abs, file.content);
+    written.push(file);
+  }
+  return written;
+}
+function expoInstall(root, deps) {
+  if (deps.length === 0) return Promise.resolve();
+  assertPackageSpecs(deps, "The install plan");
+  log.step(`Installing ${deps.map((d) => c.cyan(d)).join(", ")} with ${c.bold("expo install")}`);
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process.spawn)("npx", ["expo", "install", ...deps], {
+      cwd: root,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on(
+      "exit",
+      (code) => code === 0 ? resolve() : reject(
+        new CliError(
+          `expo install exited with code ${code}.`,
+          `Run it yourself: npx expo install ${deps.join(" ")}`
+        )
+      )
+    );
+  });
+}
+
+// src/commands/init.ts
+var import_node_fs3 = __toESM(require("node:fs"));
+var import_node_path6 = __toESM(require("node:path"));
+var CORE_ITEMS = ["kinetik-tokens", "kinetik-motion"];
+var MIN_EXPO_SDK = 54;
+function assertSupportedProject(root) {
+  const expo = installedVersion(root, "expo");
+  const sdk = major(expo);
+  if (!expo || sdk === void 0) {
+    throw new CliError(
+      "This does not look like an Expo project (expo is not installed).",
+      "Kinetik targets Expo apps: npx create-expo-app"
+    );
+  }
+  if (sdk < MIN_EXPO_SDK) {
+    throw new CliError(
+      `Expo SDK ${sdk} is not supported. Kinetik needs SDK ${MIN_EXPO_SDK}+ (Reanimated 4, New Architecture).`,
+      "Upgrade with: npx expo install expo@latest --fix"
+    );
+  }
+  if (newArchDisabled(root)) {
+    throw new CliError(
+      "The New Architecture is disabled (newArchEnabled: false). Reanimated 4 requires it.",
+      'Remove "newArchEnabled": false from app.json.'
+    );
+  }
+  return { sdk };
+}
+function newArchDisabled(root) {
+  for (const file of ["app.json", "app.config.json"]) {
+    const full = import_node_path6.default.join(root, file);
+    if (!import_node_fs3.default.existsSync(full)) continue;
+    try {
+      const json = JSON.parse(import_node_fs3.default.readFileSync(full, "utf8"));
+      const expo = json.expo ?? json;
+      if (expo.newArchEnabled === false || expo.android?.newArchEnabled === false || expo.ios?.newArchEnabled === false)
+        return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function init(options) {
+  const project = findProject(options.cwd);
+  const { sdk } = assertSupportedProject(project.root);
+  log.step(`Expo SDK ${sdk} project at ${c.dim(project.root)}`);
+  const layout = defaultLayout(project.root);
+  const config = {
+    $schema: "https://kinetik-ui.dev/schema/kinetik.json",
+    registry: options.registry ?? project.config?.registry ?? process.env.KINETIK_REGISTRY ?? DEFAULT_REGISTRY,
+    componentsDir: options.componentsDir ?? project.config?.componentsDir ?? layout.componentsDir,
+    libDir: options.libDir ?? project.config?.libDir ?? layout.libDir,
+    installed: project.config?.installed ?? {}
+  };
+  const registry = new Registry(config.registry);
+  const items = await registry.resolve(CORE_ITEMS);
+  const plan = planInstall(project, config, items);
+  const written = writeFiles(project, plan.files, options.overwrite);
+  for (const item of items) config.installed[item.name] = item.meta?.version ?? "0.0.0";
+  writeConfig(project.root, config);
+  for (const f of written)
+    log.success(`${f.status === "conflict" ? "Updated" : "Created"} ${f.path}`);
+  for (const f of plan.files.filter((p) => p.status === "conflict" && !options.overwrite)) {
+    log.warn(`Kept your changes to ${f.path} (use --overwrite to replace it)`);
+  }
+  log.success(`Wrote ${c.bold("kinetik.json")}`);
+  if (!options.skipInstall) await expoInstall(project.root, plan.missingDependencies);
+  else if (plan.missingDependencies.length)
+    log.warn(`Skipped installing: ${plan.missingDependencies.join(", ")}`);
+  return config;
+}
+
+// src/commands/add.ts
+async function add(options) {
+  if (options.names.length === 0) {
+    throw new CliError("Name at least one component.", "Example: npx kinetik-ui add glint-card");
+  }
+  options.names.forEach(assertItemName);
+  let project = findProject(options.cwd);
+  assertSupportedProject(project.root);
+  const registry = new Registry(options.registry ?? project.config?.registry ?? DEFAULT_REGISTRY);
+  const items = await registry.resolve(options.names);
+  if (!project.config && !options.dryRun) {
+    log.step("No kinetik.json yet; running init first.");
+    await init({
+      cwd: options.cwd,
+      registry: options.registry,
+      skipInstall: options.skipInstall,
+      overwrite: false
+    });
+    log.blank();
+    project = findProject(options.cwd);
+  }
+  const config = project.config ?? {
+    registry: DEFAULT_REGISTRY,
+    componentsDir: "components/kinetik",
+    libDir: "lib/kinetik",
+    installed: {}
+  };
+  if (options.registry) config.registry = options.registry;
+  const plan = planInstall(project, config, items);
+  if (options.dryRun) {
+    log.info(c.bold("Files"));
+    for (const f of plan.files) log.info(`  ${statusLabel(f.status)} ${f.path}`);
+    log.info(c.bold("Dependencies (expo install)"));
+    log.info(
+      `  ${plan.missingDependencies.length ? plan.missingDependencies.join(" ") : c.dim("none missing")}`
+    );
+    return;
+  }
+  const written = writeFiles(project, plan.files, options.overwrite);
+  for (const f of written)
+    log.success(`${f.status === "conflict" ? "Updated" : "Created"} ${f.path}`);
+  const kept = plan.files.filter((f) => f.status === "conflict" && !options.overwrite);
+  for (const f of kept) {
+    log.warn(
+      `Kept your changes to ${f.path} (use --overwrite to replace, or \`kinetik diff\` to compare)`
+    );
+  }
+  if (written.length === 0 && kept.length === 0) log.success("Files already up to date.");
+  for (const item of items) config.installed[item.name] = item.meta?.version ?? "0.0.0";
+  writeConfig(project.root, config);
+  if (!options.skipInstall) await expoInstall(project.root, plan.missingDependencies);
+  else if (plan.missingDependencies.length)
+    log.warn(`Skipped installing: ${plan.missingDependencies.join(", ")}`);
+  const requested = items.filter((i) => options.names.includes(i.name));
+  log.blank();
+  for (const item of requested) {
+    const file = plan.files.find((f) => f.item === item.name);
+    log.info(
+      `${c.ember("\u25CF")} ${c.bold(item.title ?? item.name)} ${c.dim(`\u2192 ${file?.path ?? ""}`)}`
+    );
+  }
+  if (requested.some((i) => (i.dependencies ?? []).includes("react-native-gesture-handler"))) {
+    log.info(
+      c.dim(
+        "  Gesture-driven components need the app wrapped in <GestureHandlerRootView style={{ flex: 1 }}>."
+      )
+    );
+  }
+}
+function statusLabel(status) {
+  if (status === "create") return c.green("create   ");
+  if (status === "identical") return c.dim("unchanged");
+  return c.yellow("modified ");
+}
+
+// src/commands/agents.ts
+var import_node_fs4 = __toESM(require("node:fs"));
+var import_node_path7 = __toESM(require("node:path"));
+
+// src/agents.ts
+var START = "<!-- kinetik-ui:start -->";
+var END = "<!-- kinetik-ui:end -->";
+function rules({ componentsDir, libDir }) {
+  return `Kinetik components are TypeScript source copied into this project, not a package. They live in \`${componentsDir}/\`; shared tokens, motion presets and hooks live in \`${libDir}/\`. \`kinetik.json\` records what is installed.
+
+### Adding components
+
+- Find one: \`npx kinetik-ui search <words>\` or \`npx kinetik-ui list\`. Docs for any component: \`https://kinetik-ui.dev/components/<name>.md\`.
+- Install with \`npx kinetik-ui add <name>\`. It copies the files and runs \`npx expo install\` for dependencies so native versions match the Expo SDK. Do not copy files by hand or \`npm install\` Reanimated, Gesture Handler or Skia directly.
+- Before changing a copied component, run \`npx kinetik-ui diff <name>\` to see local edits; \`add <name> --overwrite\` replaces them with the registry version.
+- \`npx kinetik-ui doctor\` checks the SDK, New Architecture, dependencies and files.
+
+### Using them
+
+- Gesture-driven components need the app root wrapped in \`<GestureHandlerRootView style={{ flex: 1 }}>\`.
+- Take colours, spacing, radius and type from \`useKinetikTheme()\`; never hard-code colours in or around Kinetik components. \`<KinetikProvider>\` sets the scheme, brand colours and haptics.
+- Animate with the presets in \`${libDir}/motion/motion.ts\` (\`spring('snappy' | 'smooth' | 'bouncy', reduced)\`, \`timing('quick' | 'base' | 'slow', reduced)\`) instead of ad-hoc springs.
+- Keep reduced-motion support: every component reads \`useReduceMotion()\` and has a still or cross-fade fallback. Do not remove it when editing.
+- Give interactive components an \`accessibilityLabel\`; keep touch targets at least 44 pt.
+- Read shared values with \`.get()\` / \`.set()\` and keep \`collapsable={false}\` on views that \`GestureDetector\` wraps (Fabric flattens them otherwise).
+- One expressive component per screen is plenty; motion should explain a change, not decorate.
+
+### MCP
+
+Agents that speak the Model Context Protocol can use \`npx -y kinetik-ui mcp\` (tools: list_components, search_components, get_component, get_install_plan, get_tokens).`;
+}
+function agentsSection(layout) {
+  return `${START}
+## Kinetik UI
+
+${rules(layout)}
+${END}
+`;
+}
+function upsertSection(existing, section) {
+  if (!existing?.trim()) return `# AGENTS.md
+
+${section}`;
+  const start = existing.indexOf(START);
+  const end = existing.indexOf(END);
+  if (start !== -1 && end > start) {
+    const after = existing.slice(end + END.length).replace(/^\r?\n/, "");
+    return `${existing.slice(0, start)}${section}${after}`;
+  }
+  return `${existing.replace(/\s*$/, "")}
+
+${section}`;
+}
+function skillFile(layout) {
+  return `---
+name: kinetik-ui
+description: Add or edit Kinetik UI motion components (animated cards, buttons, sliders, text effects, shader backgrounds, sheets, toasts) in an Expo / React Native app. Use when the user wants animation, gestures, haptics or Skia effects, or touches files in ${layout.componentsDir}/.
+---
+
+# Kinetik UI
+
+${rules(layout).replace(/^### /gm, "## ")}
+`;
+}
+
+// src/commands/agents.ts
+function agents({ cwd, skill }) {
+  const project = findProject(cwd);
+  const layout = project.config ?? defaultLayout(project.root);
+  const file = import_node_path7.default.join(project.root, "AGENTS.md");
+  const existing = import_node_fs4.default.existsSync(file) ? import_node_fs4.default.readFileSync(file, "utf8") : null;
+  const next = upsertSection(existing, agentsSection(layout));
+  if (next === existing) {
+    log.step("AGENTS.md is up to date");
+  } else {
+    import_node_fs4.default.writeFileSync(file, next);
+    log.success(`${existing ? "Updated" : "Created"} AGENTS.md`);
+  }
+  if (skill) {
+    const skillPath = import_node_path7.default.join(project.root, ".claude", "skills", "kinetik-ui", "SKILL.md");
+    import_node_fs4.default.mkdirSync(import_node_path7.default.dirname(skillPath), { recursive: true });
+    import_node_fs4.default.writeFileSync(skillPath, skillFile(layout));
+    log.success(`Wrote ${import_node_path7.default.relative(project.root, skillPath).split(import_node_path7.default.sep).join("/")}`);
+  }
+  log.info(c.dim("  Agents can also use the MCP server: npx -y kinetik-ui mcp"));
+}
+
+// src/commands/diff.ts
+var import_node_fs5 = __toESM(require("node:fs"));
+var import_node_path8 = __toESM(require("node:path"));
+
+// src/diff.ts
+function diffLines(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const max = n + m;
+  const v = /* @__PURE__ */ new Map([[1, 0]]);
+  const trace = [];
+  outer: for (let d = 0; d <= max; d++) {
+    trace.push(new Map(v));
+    for (let k = -d; k <= d; k += 2) {
+      const down = k === -d || k !== d && (v.get(k - 1) ?? -1) < (v.get(k + 1) ?? -1);
+      let x2 = down ? v.get(k + 1) ?? 0 : (v.get(k - 1) ?? 0) + 1;
+      let y2 = x2 - k;
+      while (x2 < n && y2 < m && a[x2] === b[y2]) {
+        x2++;
+        y2++;
+      }
+      v.set(k, x2);
+      if (x2 >= n && y2 >= m) break outer;
+    }
+  }
+  const ops = [];
+  let x = n;
+  let y = m;
+  for (let d = trace.length - 1; d >= 0 && (x > 0 || y > 0); d--) {
+    const vd = trace[d];
+    const k = x - y;
+    const down = k === -d || k !== d && (vd.get(k - 1) ?? -1) < (vd.get(k + 1) ?? -1);
+    const prevK = down ? k + 1 : k - 1;
+    const prevX = vd.get(prevK) ?? 0;
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) {
+      x--;
+      y--;
+      ops.push({ kind: " ", line: a[x] });
+    }
+    if (d > 0) {
+      if (down) ops.push({ kind: "+", line: b[--y] });
+      else ops.push({ kind: "-", line: a[--x] });
+    }
+  }
+  return ops.reverse();
+}
+function unifiedDiff(oldText, newText, context = 3) {
+  const ops = diffLines(
+    oldText.replace(/\r\n/g, "\n").split("\n"),
+    newText.replace(/\r\n/g, "\n").split("\n")
+  );
+  if (ops.every((o) => o.kind === " ")) return [];
+  const out = [];
+  let i = 0;
+  while (i < ops.length) {
+    if (ops[i].kind === " ") {
+      i++;
+      continue;
+    }
+    const start = Math.max(0, i - context);
+    let end = i;
+    while (end < ops.length) {
+      if (ops[end].kind !== " ") {
+        end++;
+        continue;
+      }
+      let run = 0;
+      while (end + run < ops.length && ops[end + run].kind === " ") run++;
+      if (run > context * 2 || end + run >= ops.length) {
+        end = Math.min(ops.length, end + context);
+        break;
+      }
+      end += run;
+    }
+    out.push("@@");
+    for (let j = start; j < end; j++) out.push(`${ops[j].kind}${ops[j].line}`);
+    i = end;
+  }
+  return out;
+}
+
+// src/commands/diff.ts
+async function diff(options) {
+  const project = findProject(options.cwd);
+  const config = project.config;
+  if (!config) throw new CliError("kinetik.json not found.", "Run: npx kinetik-ui init");
+  const names = options.names.length ? options.names : Object.keys(config.installed);
+  if (names.length === 0) {
+    log.info("Nothing installed yet.");
+    return 0;
+  }
+  const registry = new Registry(options.registry ?? config.registry);
+  const items = await Promise.all(names.map((n) => registry.item(n)));
+  const all = await registry.resolve(names);
+  const plan = planInstall(project, config, all);
+  const wanted = new Set(items.map((i) => i.name));
+  let changed = 0;
+  for (const file of plan.files.filter((f) => wanted.has(f.item))) {
+    const abs = import_node_path8.default.join(project.root, file.path);
+    if (!import_node_fs5.default.existsSync(abs)) {
+      log.info(`${c.red("missing")} ${file.path}`);
+      changed++;
+      continue;
+    }
+    if (file.status === "identical") continue;
+    changed++;
+    const local = import_node_fs5.default.readFileSync(abs, "utf8");
+    log.info(
+      c.bold(`${file.path}`) + c.dim(
+        `  (${file.item}: upstream ${config.installed[file.item] ?? "?"} \u2192 registry ${all.find((i) => i.name === file.item)?.meta?.version ?? "?"})`
+      )
+    );
+    for (const line of unifiedDiff(file.content, local)) {
+      if (line.startsWith("@@")) log.info(c.cyan(line));
+      else if (line.startsWith("+")) log.info(c.green(line));
+      else if (line.startsWith("-")) log.info(c.red(line));
+      else log.info(c.dim(line));
+    }
+    log.blank();
+  }
+  log.info(
+    changed ? `${changed} file(s) differ from the registry.` : c.green("All files match the registry.")
+  );
+  return changed;
+}
+
+// src/commands/doctor.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs6 = __toESM(require("node:fs"));
+var import_node_path9 = __toESM(require("node:path"));
+async function doctor(options) {
+  const project = findProject(options.cwd);
+  const checks = [];
+  const push = (level, message, hint) => checks.push({ level, message, ...hint ? { hint } : null });
+  const expo = installedVersion(project.root, "expo");
+  const sdk = major(expo);
+  if (!expo || sdk === void 0)
+    push("error", "expo is not installed", "Kinetik targets Expo apps.");
+  else if (sdk < MIN_EXPO_SDK)
+    push(
+      "error",
+      `Expo SDK ${sdk} is below the supported minimum (${MIN_EXPO_SDK})`,
+      "npx expo install expo@latest --fix"
+    );
+  else push("ok", `Expo SDK ${sdk} (expo ${expo})`);
+  if (newArchDisabled(project.root))
+    push(
+      "error",
+      "New Architecture is disabled",
+      'Remove "newArchEnabled": false from app.json; Reanimated 4 requires it.'
+    );
+  else push("ok", "New Architecture enabled");
+  const rn = installedVersion(project.root, "react-native");
+  if (rn) push("ok", `react-native ${rn}`);
+  const babel = ["babel.config.js", "babel.config.cjs", ".babelrc"].map((f) => import_node_path9.default.join(project.root, f)).find((f) => import_node_fs6.default.existsSync(f));
+  if (babel && /react-native-reanimated\/plugin/.test(import_node_fs6.default.readFileSync(babel, "utf8"))) {
+    push(
+      "warn",
+      `${import_node_path9.default.basename(babel)} lists react-native-reanimated/plugin`,
+      "babel-preset-expo already adds the worklets plugin; remove the manual entry."
+    );
+  }
+  const config = project.config;
+  if (!config) {
+    push("warn", "kinetik.json not found", "Run: npx kinetik-ui init");
+  } else {
+    push(
+      "ok",
+      `kinetik.json \u2192 components in ${config.componentsDir}, shared code in ${config.libDir}`
+    );
+    const names = Object.keys(config.installed);
+    if (names.length) {
+      try {
+        const registry = new Registry(options.registry ?? config.registry);
+        const items = await registry.resolve(names);
+        const plan = planInstall(project, config, items);
+        for (const dep of plan.dependencies) {
+          if (!dependencyVersion(project.pkg, dep))
+            push("error", `${dep} is required but not in package.json`, `npx expo install ${dep}`);
+        }
+        const missing = plan.files.filter((f) => !import_node_fs6.default.existsSync(import_node_path9.default.join(project.root, f.path)));
+        const modified = plan.files.filter((f) => f.status === "conflict");
+        for (const f of missing)
+          push(
+            "error",
+            `${f.path} is missing (from ${f.item})`,
+            `npx kinetik-ui add ${f.item} --overwrite`
+          );
+        if (modified.length) {
+          push(
+            "warn",
+            `${modified.length} installed file(s) differ from the registry`,
+            "Run `npx kinetik-ui diff` to review."
+          );
+        } else if (!missing.length) {
+          push("ok", `${names.length} registry item(s) installed and in sync`);
+        }
+        if (plan.dependencies.includes("react-native-gesture-handler") && !hasGestureRoot(project.root)) {
+          push(
+            "warn",
+            "No <GestureHandlerRootView> found in the app",
+            "Wrap your root layout in <GestureHandlerRootView style={{ flex: 1 }}>."
+          );
+        }
+      } catch (error) {
+        push("warn", `Could not reach the registry to compare files (${error.message})`);
+      }
+    }
+  }
+  if (options.expoCheck && expo) {
+    const res = (0, import_node_child_process2.spawnSync)("npx", ["expo", "install", "--check"], {
+      cwd: project.root,
+      encoding: "utf8",
+      shell: process.platform === "win32",
+      env: { ...process.env, CI: "1" }
+    });
+    const output = `${res.stdout ?? ""}${res.stderr ?? ""}`.trim();
+    if (res.status === 0) push("ok", "Dependency versions match the Expo SDK");
+    else
+      push(
+        "error",
+        "Some dependencies do not match the Expo SDK",
+        `npx expo install --fix
+${indent(output)}`
+      );
+  }
+  for (const check of checks) {
+    const icon = check.level === "ok" ? c.green("\u2714") : check.level === "warn" ? c.yellow("!") : c.red("\u2716");
+    log.info(`${icon} ${check.message}`);
+    if (check.hint) log.info(c.dim(indent(check.hint)));
+  }
+  const errors = checks.filter((x) => x.level === "error").length;
+  const warnings = checks.filter((x) => x.level === "warn").length;
+  log.blank();
+  log.info(
+    errors || warnings ? `${errors} error(s), ${warnings} warning(s)` : c.green("Everything looks good.")
+  );
+  return errors;
+}
+function indent(s) {
+  return s.split("\n").map((l) => `    ${l}`).join("\n");
+}
+function hasGestureRoot(root) {
+  const candidates = [
+    "App.tsx",
+    "App.js",
+    "app/_layout.tsx",
+    "src/app/_layout.tsx",
+    "app/_layout.js",
+    "src/app/_layout.js",
+    "index.tsx",
+    "index.js"
+  ];
+  return candidates.some((f) => {
+    const full = import_node_path9.default.join(root, f);
+    return import_node_fs6.default.existsSync(full) && import_node_fs6.default.readFileSync(full, "utf8").includes("GestureHandlerRootView");
+  });
+}
+
+// src/commands/list.ts
+var CATEGORY_ORDER = [
+  "background",
+  "card",
+  "interaction",
+  "text",
+  "navigation",
+  "feedback",
+  "data",
+  "screen"
+];
+async function loadComponents(cwd, registryOverride) {
+  let installed = {};
+  let base = registryOverride ?? process.env.KINETIK_REGISTRY ?? DEFAULT_REGISTRY;
+  try {
+    const project = findProject(cwd);
+    installed = project.config?.installed ?? {};
+    if (!registryOverride && project.config) base = project.config.registry;
+  } catch {
+  }
+  const index = await new Registry(base).index();
+  return { items: index.items.filter((i) => i.meta?.kind !== "shared"), installed };
+}
+function printItems(items, installed) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const cat = item.meta?.category ?? item.categories?.[0] ?? "other";
+    groups.set(cat, [...groups.get(cat) ?? [], item]);
+  }
+  const order = [
+    ...CATEGORY_ORDER,
+    ...[...groups.keys()].filter((k) => !CATEGORY_ORDER.includes(k))
+  ];
+  const width = Math.max(...items.map((i) => i.name.length), 10) + 2;
+  for (const cat of order) {
+    const group = groups.get(cat);
+    if (!group) continue;
+    log.info(c.bold(cat.toUpperCase()));
+    for (const item of group) {
+      const mark = installed[item.name] ? c.green("\u25CF") : c.dim("\u25CB");
+      log.info(`  ${mark} ${item.name.padEnd(width)}${c.dim(item.description ?? "")}`);
+    }
+    log.blank();
+  }
+}
+async function list(options) {
+  const { items, installed } = await loadComponents(options.cwd, options.registry);
+  if (options.json) {
+    const rows = items.map((i) => ({
+      name: i.name,
+      title: i.title,
+      description: i.description,
+      category: i.meta?.category,
+      installed: installed[i.name] ?? null
+    }));
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  printItems(items, installed);
+  log.info(
+    c.dim(`${items.length} components \xB7 \u25CF installed \xB7 add one with: npx kinetik-ui add <name>`)
+  );
+}
+
+// src/commands/mcp.ts
+async function mcp({ cwd, registry, version }) {
+  const config = () => {
+    try {
+      return findProject(cwd).config;
+    } catch {
+      return null;
+    }
+  };
+  const base = registry ?? config()?.registry ?? DEFAULT_REGISTRY;
+  const { startStdioServer } = await Promise.resolve().then(() => __toESM(require_dist()));
+  await startStdioServer({
+    registry: new Registry(base),
+    // Re-read on every call so installs made while the agent runs show up.
+    installed: async () => config()?.installed ?? {},
+    version
+  });
+}
+
+// src/commands/search.ts
+function score(item, query) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (terms.length === 0) return 0;
+  let total = 0;
+  for (const term of terms) {
+    const name = item.name.toLowerCase();
+    const title = (item.title ?? "").toLowerCase();
+    const desc = (item.description ?? "").toLowerCase();
+    const cat = (item.meta?.category ?? item.categories?.[0] ?? "").toLowerCase();
+    let s = 0;
+    if (name === term) s = 10;
+    else if (name.includes(term)) s = 6;
+    else if (title.includes(term)) s = 5;
+    else if (cat.includes(term)) s = 3;
+    else if (desc.includes(term)) s = 2;
+    if (s === 0) return 0;
+    total += s;
+  }
+  return total;
+}
+function searchItems(items, query) {
+  return items.map((item) => ({ item, s: score(item, query) })).filter((r) => r.s > 0).sort((a, b) => b.s - a.s || a.item.name.localeCompare(b.item.name)).map((r) => r.item);
+}
+async function search(options) {
+  const { items, installed } = await loadComponents(options.cwd, options.registry);
+  const hits = searchItems(items, options.query);
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        hits.map((i) => ({ name: i.name, title: i.title, description: i.description })),
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (hits.length === 0) {
+    log.info(
+      `No components match ${c.bold(`"${options.query}"`)}. Try ${c.cyan("npx kinetik-ui list")}.`
+    );
+    return;
+  }
+  printItems(hits, installed);
+}
+
+// src/index.ts
+var VERSION = require_package().version;
+var HELP = `
+${c.ember("kinetik")} ${c.dim(`v${VERSION}`)} \u2014 motion components for Expo, copied into your project
+
+${c.bold("Usage")}
+  npx kinetik-ui <command> [options]
+
+${c.bold("Commands")}
+  init                 Set up kinetik.json, tokens and motion presets
+  add <name...>        Copy components into the project and expo-install their dependencies
+  list                 List every component (${c.green("\u25CF")} installed)
+  search <query>       Find components by name, category or description
+  doctor               Check Expo SDK, New Architecture, dependencies and installed files
+  diff [name...]       Show how your copies differ from the registry
+  agents               Add Kinetik guidance for AI agents to AGENTS.md (--skill: also a skill file)
+  mcp                  Serve the registry to AI agents (Model Context Protocol, stdio)
+
+${c.bold("Options")}
+  --registry <url|dir> Registry base (default: kinetik.json "registry" or https://kinetik-ui.dev/r)
+  --overwrite          Replace files you have modified (add, init)
+  --dry-run            Show what add would do without writing anything
+  --skip-install       Do not run expo install
+  --components-dir     Where components go (init; default components/kinetik or src/components/kinetik)
+  --lib-dir            Where shared code goes (init; default lib/kinetik or src/lib/kinetik)
+  --skill              Also write .claude/skills/kinetik-ui/SKILL.md (agents)
+  --json               Machine-readable output (list, search)
+  --no-expo-check      Skip \`expo install --check\` (doctor)
+  -v, --version        Print the version
+  -h, --help           Show this help
+`;
+async function main(argv) {
+  const { values, positionals } = (0, import_node_util.parseArgs)({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      registry: { type: "string" },
+      overwrite: { type: "boolean", default: false },
+      "dry-run": { type: "boolean", default: false },
+      "skip-install": { type: "boolean", default: false },
+      "components-dir": { type: "string" },
+      "lib-dir": { type: "string" },
+      json: { type: "boolean", default: false },
+      skill: { type: "boolean", default: false },
+      "no-expo-check": { type: "boolean", default: false },
+      cwd: { type: "string" },
+      version: { type: "boolean", short: "v", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  const [command, ...rest] = positionals;
+  const cwd = values.cwd ?? process.cwd();
+  const registry = values.registry ?? process.env.KINETIK_REGISTRY;
+  if (values.version) {
+    log.info(VERSION);
+    return 0;
+  }
+  if (values.help || !command) {
+    log.info(HELP);
+    return 0;
+  }
+  switch (command) {
+    case "init":
+      await init({
+        cwd,
+        registry,
+        componentsDir: values["components-dir"],
+        libDir: values["lib-dir"],
+        skipInstall: values["skip-install"],
+        overwrite: values.overwrite
+      });
+      log.blank();
+      log.info(`Next: ${c.cyan("npx kinetik-ui add glint-card")}`);
+      return 0;
+    case "add":
+      await add({
+        cwd,
+        names: rest,
+        registry,
+        skipInstall: values["skip-install"],
+        overwrite: values.overwrite,
+        dryRun: values["dry-run"]
+      });
+      return 0;
+    case "list":
+    case "ls":
+      await list({ cwd, registry, json: values.json });
+      return 0;
+    case "search":
+      if (rest.length === 0)
+        throw new CliError("Give a search query.", "Example: npx kinetik-ui search card");
+      await search({ cwd, registry, query: rest.join(" "), json: values.json });
+      return 0;
+    case "doctor":
+      return await doctor({ cwd, registry, expoCheck: !values["no-expo-check"] }) > 0 ? 1 : 0;
+    case "diff":
+      return await diff({ cwd, registry, names: rest }) > 0 ? 1 : 0;
+    case "agents":
+      agents({ cwd, skill: values.skill });
+      return 0;
+    case "mcp":
+      await mcp({ cwd, registry, version: VERSION });
+      return new Promise(() => {
+      });
+    // Runs until the client closes stdin.
+    default:
+      throw new CliError(`Unknown command "${command}".`, "Run npx kinetik-ui --help");
+  }
+}
+main(process.argv.slice(2)).then(
+  (code) => process.exit(code),
+  (error) => {
+    if (error instanceof CliError) {
+      log.error(error.message);
+      if (error.hint) log.info(c.dim(`  ${error.hint}`));
+    } else if (error instanceof Error && "code" in error && String(error.code).startsWith("ERR_PARSE_ARGS")) {
+      log.error(error.message);
+    } else {
+      log.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    }
+    process.exit(1);
+  }
+);