wensity 0.1.0

package/README.md

@@ -0,0 +1,14 @@
+# Wensity CLI
+
+The `wensity` CLI installs source-owned components from the Wensity registry.
+
+```bash
+pnpm dlx wensity init
+pnpm dlx wensity login
+pnpm dlx wensity list
+pnpm dlx wensity add liquid-multimodal-input
+pnpm dlx wensity whoami
+```
+
+Premium components require an API token from the Wensity dashboard. Tokens are
+stored at `~/.config/wensity/credentials.json` with `0600` permissions.

package/dist/index.js

@@ -0,0 +1,1031 @@
+#!/usr/bin/env node
+
+// src/commands.ts
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname5, join as join6 } from "path";
+
+// src/constants.ts
+var CLI_NAME = "wensity";
+var CLI_VERSION = "0.1.0";
+var CONFIG_FILE_NAME = "wensity.json";
+var DEFAULT_API_ORIGIN = "https://wensity.com";
+var DEFAULT_REGISTRY_PATH = "/api/registry";
+var DEFAULT_COMPONENTS_DIR = "src/components/wensity";
+var DEFAULT_UTILS_PATH = "src/lib/utils";
+var DEFAULT_COMPONENTS_ALIAS = "@/components/wensity";
+var DEFAULT_UTILS_ALIAS = "@/lib/utils";
+var HELP_TEXT = `Wensity CLI ${CLI_VERSION}
+
+Usage:
+  wensity init [options]
+  wensity login [options]
+  wensity logout
+  wensity whoami [--json]
+  wensity list [options]
+  wensity add <slug> [options]
+  wensity update <slug> [options]
+  wensity version
+
+Commands:
+  init       Create wensity.json and local helper files
+  login      Save a Wensity API token for premium component access
+  logout     Remove saved CLI credentials
+  whoami     Verify the saved token and print the authenticated account
+  list       List registry components
+  add        Download a component source file into this project
+  update     Re-download a component and overwrite the local copy
+  version    Print the CLI version
+
+Options:
+  --api-url <url>      Override the Wensity app origin, defaults to ${DEFAULT_API_ORIGIN}
+  --registry <url>     Override the registry endpoint
+  --token <token>      Provide a token non-interactively for login
+  --force              Overwrite generated files when adding or initializing
+  --no-install         Write files without running the package manager
+  --dry-run            Print planned writes and installs without changing files
+  --json               Print machine-readable output where supported
+  --help               Show help
+  --version            Print the CLI version
+`;
+
+// src/errors.ts
+var CliError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+};
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/args.ts
+function parseArgs(argv) {
+  const positionals = [];
+  const options = /* @__PURE__ */ new Map();
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+    if (token === "--") {
+      positionals.push(...argv.slice(index + 1));
+      break;
+    }
+    const inlineValueIndex = token.indexOf("=");
+    const rawName = inlineValueIndex > -1 ? token.slice(2, inlineValueIndex) : token.slice(2);
+    const name = normalizeOptionName(rawName);
+    if (!name) {
+      throw new CliError(`Invalid option: ${token}`);
+    }
+    if (inlineValueIndex > -1) {
+      options.set(name, token.slice(inlineValueIndex + 1));
+      continue;
+    }
+    const nextToken = argv[index + 1];
+    if (nextToken && !nextToken.startsWith("--") && expectsValue(name)) {
+      options.set(name, nextToken);
+      index += 1;
+      continue;
+    }
+    options.set(name, true);
+  }
+  return { positionals, options };
+}
+function getStringOption(args, name) {
+  const value = args.options.get(name);
+  if (value === void 0) return void 0;
+  if (typeof value === "boolean") {
+    throw new CliError(`--${name} expects a value.`);
+  }
+  return value;
+}
+function hasFlag(args, name) {
+  return args.options.get(name) === true;
+}
+function expectsValue(name) {
+  return ["api-url", "registry", "token"].includes(name);
+}
+function normalizeOptionName(name) {
+  if (name === "dry") return "dry-run";
+  return name;
+}
+
+// src/config.ts
+import { existsSync } from "fs";
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join2, relative as relative2 } from "path";
+
+// src/paths.ts
+import { dirname, isAbsolute, relative, resolve, sep } from "path";
+function normalizeUrlOrigin(input) {
+  const trimmed = input.trim().replace(/\/+$/, "");
+  const withProtocol = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  const url = new URL(withProtocol);
+  if (url.protocol !== "https:" && !isLocalHttpUrl(url)) {
+    throw new CliError("API URL must use HTTPS, except for localhost development URLs.");
+  }
+  return url.origin;
+}
+function isLocalHttpUrl(url) {
+  if (url.protocol !== "http:") return false;
+  return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+}
+function joinUrl(originOrUrl, path) {
+  const base = originOrUrl.endsWith("/") ? originOrUrl : `${originOrUrl}/`;
+  const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+  return new URL(normalizedPath, base).toString();
+}
+function resolveInside(root, candidate) {
+  if (isAbsolute(candidate)) {
+    throw new Error(`Path must be project-relative: ${candidate}`);
+  }
+  const absolutePath = resolve(root, candidate);
+  const relativePath = relative(root, absolutePath);
+  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+    throw new Error(`Path escapes the project: ${candidate}`);
+  }
+  return absolutePath;
+}
+function toPosixPath(input) {
+  return input.split(sep).join("/");
+}
+function parentDirectory(input) {
+  return dirname(input);
+}
+function stripKnownComponentPrefix(path) {
+  const normalized = path.replace(/\\/g, "/").replace(/^\/+/, "");
+  const prefixes = ["components/wensity/", "src/components/wensity/"];
+  const prefix = prefixes.find((candidate) => normalized.startsWith(candidate));
+  return prefix ? normalized.slice(prefix.length) : normalized;
+}
+function sanitizePayloadPath(path, fallbackFileName) {
+  const normalized = stripKnownComponentPrefix(path);
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length === 0) return fallbackFileName;
+  for (const part of parts) {
+    if (part === "." || part === ".." || part.includes("\0")) {
+      throw new Error(`Unsafe registry file path: ${path}`);
+    }
+  }
+  const last = parts.at(-1) ?? fallbackFileName;
+  if (!/\.(tsx|ts|jsx|js)$/.test(last)) {
+    parts[parts.length - 1] = fallbackFileName;
+  }
+  return parts.join("/");
+}
+function componentFileName(slug) {
+  return `${slugToPascalCase(slug)}.tsx`;
+}
+function slugToPascalCase(slug) {
+  return slug.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+}
+function extensionlessPath(path) {
+  return path.replace(/\.(tsx|ts|jsx|js)$/, "");
+}
+
+// src/config.ts
+async function loadConfig(cwd, overrides = {}) {
+  const foundPath = await findUp(cwd, CONFIG_FILE_NAME);
+  const projectRoot = foundPath ? dirname2(foundPath) : cwd;
+  const configPath = foundPath ?? join2(projectRoot, CONFIG_FILE_NAME);
+  const defaults = createDefaultConfig(projectRoot, overrides.apiUrl ?? DEFAULT_API_ORIGIN);
+  if (!foundPath) {
+    return {
+      config: normalizeConfig(defaults, overrides),
+      configPath,
+      projectRoot,
+      exists: false
+    };
+  }
+  try {
+    const parsed = JSON.parse(await readFile(foundPath, "utf8"));
+    return {
+      config: normalizeConfig({ ...defaults, ...parsed }, overrides),
+      configPath,
+      projectRoot,
+      exists: true
+    };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new CliError(`${CONFIG_FILE_NAME} contains invalid JSON.`);
+    }
+    throw error;
+  }
+}
+function createDefaultConfig(projectRoot, apiUrl = DEFAULT_API_ORIGIN) {
+  const apiOrigin = normalizeUrlOrigin(apiUrl);
+  return {
+    $schema: joinUrl(apiOrigin, "/schema/wensity.json"),
+    registry: joinUrl(apiOrigin, DEFAULT_REGISTRY_PATH),
+    components: DEFAULT_COMPONENTS_DIR,
+    utils: DEFAULT_UTILS_PATH,
+    tailwind: {
+      config: detectTailwindConfig(projectRoot),
+      css: detectGlobalCss(projectRoot)
+    },
+    aliases: {
+      components: DEFAULT_COMPONENTS_ALIAS,
+      utils: DEFAULT_UTILS_ALIAS
+    }
+  };
+}
+async function writeConfigFile(path, config, force) {
+  if (!force && await fileExists(path)) {
+    throw new CliError(`${toPosixPath(relative2(process.cwd(), path))} already exists. Use --force to overwrite it.`);
+  }
+  await mkdir(dirname2(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function resolveConfiguredFilePath(projectRoot, relativePath, extension = "ts") {
+  try {
+    return resolveInside(projectRoot, withExtension(relativePath, extension));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CliError(message);
+  }
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function findUp(start, fileName) {
+  let current = start;
+  while (true) {
+    const candidate = join2(current, fileName);
+    if (await fileExists(candidate)) return candidate;
+    const parent = dirname2(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+function normalizeConfig(config, overrides) {
+  const apiOrigin = overrides.apiUrl ? normalizeUrlOrigin(overrides.apiUrl) : void 0;
+  return {
+    ...config,
+    registry: overrides.registry ?? (apiOrigin ? joinUrl(apiOrigin, DEFAULT_REGISTRY_PATH) : config.registry),
+    components: config.components || DEFAULT_COMPONENTS_DIR,
+    utils: config.utils || DEFAULT_UTILS_PATH,
+    aliases: {
+      components: config.aliases?.components || DEFAULT_COMPONENTS_ALIAS,
+      utils: config.aliases?.utils || DEFAULT_UTILS_ALIAS
+    }
+  };
+}
+function detectTailwindConfig(projectRoot) {
+  const candidates = ["tailwind.config.ts", "tailwind.config.js", "tailwind.config.mjs"];
+  return candidates.find((candidate) => existsSync(join2(projectRoot, candidate))) ?? "tailwind.config.ts";
+}
+function detectGlobalCss(projectRoot) {
+  const candidates = ["src/app/globals.css", "src/styles/globals.css", "app/globals.css"];
+  return candidates.find((candidate) => existsSync(join2(projectRoot, candidate))) ?? "src/app/globals.css";
+}
+function withExtension(path, extension) {
+  if (/\.(ts|tsx|js|jsx)$/.test(path)) return path;
+  return `${path}.${extension}`;
+}
+
+// src/credentials.ts
+import { mkdir as mkdir2, readFile as readFile2, rename, rm, writeFile as writeFile2, chmod } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
+import { randomUUID } from "crypto";
+import { stdin, stdout } from "process";
+function credentialsPath(env) {
+  if (env.WENSITY_CREDENTIALS_FILE) return env.WENSITY_CREDENTIALS_FILE;
+  const configHome = env.WENSITY_CONFIG_HOME ?? env.XDG_CONFIG_HOME ?? join3(requiredHome(env), ".config");
+  return join3(configHome, "wensity", "credentials.json");
+}
+async function readCredentials(env) {
+  const path = credentialsPath(env);
+  try {
+    const content = await readFile2(path, "utf8");
+    const parsed = JSON.parse(content);
+    if (parsed.version !== 1 || !parsed.token || !parsed.apiBaseUrl) {
+      throw new CliError(`Credentials at ${path} are not valid. Run wensity login again.`);
+    }
+    return parsed;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    if (error instanceof SyntaxError) {
+      throw new CliError(`Credentials at ${path} are not valid JSON. Run wensity login again.`);
+    }
+    throw error;
+  }
+}
+async function writeCredentials(env, credentials) {
+  const path = credentialsPath(env);
+  const directory = dirname3(path);
+  const temporaryPath = join3(directory, `.credentials.${randomUUID()}.tmp`);
+  await mkdir2(directory, { recursive: true, mode: 448 });
+  await writeFile2(temporaryPath, `${JSON.stringify(credentials, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await rename(temporaryPath, path);
+  await chmod(path, 384);
+  return path;
+}
+async function deleteCredentials(env) {
+  const path = credentialsPath(env);
+  try {
+    await rm(path, { force: false });
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function readTokenInteractively(prompt = "Wensity API token: ") {
+  if (!stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of stdin) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8").trim();
+  }
+  return new Promise((resolveToken, rejectToken) => {
+    const input = stdin;
+    const previousRawMode = input.isRaw;
+    let token = "";
+    function cleanup() {
+      input.off("data", onData);
+      if (typeof previousRawMode === "boolean") {
+        input.setRawMode(previousRawMode);
+      }
+      input.pause();
+    }
+    function onData(chunk) {
+      const value = chunk.toString("utf8");
+      if (value === "") {
+        cleanup();
+        stdout.write("\n");
+        rejectToken(new CliError("Login cancelled.", 130));
+        return;
+      }
+      if (value === "\r" || value === "\n" || value === "\r\n") {
+        cleanup();
+        stdout.write("\n");
+        resolveToken(token.trim());
+        return;
+      }
+      if (value === "\x7F") {
+        token = token.slice(0, -1);
+        return;
+      }
+      token += value;
+    }
+    stdout.write(prompt);
+    input.setRawMode(true);
+    input.resume();
+    input.on("data", onData);
+  });
+}
+function requiredHome(env) {
+  if (env.HOME) return env.HOME;
+  throw new CliError("HOME is not set, so the CLI cannot locate ~/.config/wensity.");
+}
+
+// src/http.ts
+async function requestJson(url, options = {}) {
+  const headers = new Headers(options.headers);
+  headers.set("accept", "application/json");
+  headers.set("user-agent", `${CLI_NAME}/${CLI_VERSION}`);
+  if (options.body && !headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+  if (options.token) {
+    headers.set("authorization", `Bearer ${options.token}`);
+  }
+  let response;
+  try {
+    response = await fetch(url, { ...options, headers });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown network error";
+    throw new CliError(`Could not reach ${url}: ${message}`);
+  }
+  const text = await response.text();
+  const payload = parseJson(text);
+  if (!response.ok) {
+    const message = formatErrorMessage(payload) ?? response.statusText;
+    throw new CliError(`${response.status} ${message}`);
+  }
+  return payload;
+}
+function parseJson(text) {
+  if (!text.trim()) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new CliError("Registry returned invalid JSON.");
+  }
+}
+function formatErrorMessage(payload) {
+  if (!payload || typeof payload !== "object") return void 0;
+  const record = payload;
+  const code = typeof record.error === "string" ? record.error : void 0;
+  const message = typeof record.message === "string" ? record.message : code;
+  if (code === "pro_license_required") {
+    const base = message ?? "This component requires Wensity Pro.";
+    return `${base}
+Upgrade here: https://wensity.com/pricing`;
+  }
+  return message;
+}
+
+// src/package-manager.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { spawnSync } from "child_process";
+import { join as join4 } from "path";
+
+// src/output.ts
+function print(message = "") {
+  process.stdout.write(`${message}
+`);
+}
+function warn(message) {
+  process.stderr.write(`Warning: ${message}
+`);
+}
+function info(message) {
+  process.stderr.write(`${message}
+`);
+}
+function printJson(value) {
+  print(JSON.stringify(value, null, 2));
+}
+function formatList(items) {
+  return items.map((item) => `  - ${item}`).join("\n");
+}
+
+// src/package-manager.ts
+function detectPackageManager(projectRoot) {
+  if (existsSync2(join4(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join4(projectRoot, "bun.lockb")) || existsSync2(join4(projectRoot, "bun.lock"))) return "bun";
+  if (existsSync2(join4(projectRoot, "yarn.lock"))) return "yarn";
+  if (existsSync2(join4(projectRoot, "package-lock.json"))) return "npm";
+  return "npm";
+}
+function missingDependencies(projectRoot, dependencies) {
+  const packageJsonPath = join4(projectRoot, "package.json");
+  if (!existsSync2(packageJsonPath)) return dependencies;
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  const installed = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies,
+    ...packageJson.peerDependencies,
+    ...packageJson.optionalDependencies
+  };
+  return dependencies.filter((dependency) => !installed[dependency]);
+}
+function runInstall(projectRoot, dependencies) {
+  if (dependencies.length === 0) return;
+  const packageJsonPath = join4(projectRoot, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    warn(`No package.json found. Install these dependencies manually: ${dependencies.join(" ")}`);
+    return;
+  }
+  const packageManager = detectPackageManager(projectRoot);
+  const args = installArgs(packageManager, dependencies);
+  const result = spawnSync(packageManager, args, {
+    cwd: projectRoot,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (result.error) {
+    throw new CliError(`Could not run ${packageManager}: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new CliError(`${packageManager} ${args.join(" ")} failed with exit code ${result.status ?? 1}.`);
+  }
+}
+function installArgs(packageManager, dependencies) {
+  switch (packageManager) {
+    case "pnpm":
+      return ["add", ...dependencies];
+    case "yarn":
+      return ["add", ...dependencies];
+    case "bun":
+      return ["add", ...dependencies];
+    case "npm":
+      return ["install", ...dependencies];
+  }
+}
+
+// src/component-install.ts
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname4, join as join5, relative as relative3 } from "path";
+
+// src/templates.ts
+function cnUtilityTemplate() {
+  return `import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]): string {
+  return twMerge(clsx(inputs));
+}
+`;
+}
+function primitivesTemplate(utilsImport) {
+  return `"use client";
+
+import * as React from "react";
+import { cn } from "${utilsImport}";
+
+type Size = "sm" | "md" | "lg";
+type Tone = "chili" | "violet" | "emerald" | "sky" | "amber" | "white" | "graphite";
+
+type SharedProps = {
+  children: React.ReactNode;
+  size?: Size;
+  tone?: Tone;
+  showArrow?: boolean;
+  className?: string;
+  href?: string;
+  external?: boolean;
+  disabled?: boolean;
+};
+
+type ButtonProps = SharedProps & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof SharedProps>;
+type AnchorProps = SharedProps & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, keyof SharedProps | "href">;
+
+const sizes: Record<Size, string> = {
+  sm: "h-9 px-4 text-[13px]",
+  md: "h-10 px-5 text-sm",
+  lg: "h-12 px-6 text-[15px]",
+};
+
+const tones: Record<Tone, string> = {
+  chili: "from-chili-400 via-chili-500 to-chili-700 text-white shadow-[0_10px_30px_-10px_rgba(205,28,24,0.55)]",
+  violet: "from-violet-300 via-violet-600 to-violet-800 text-white shadow-[0_10px_30px_-10px_rgba(124,58,237,0.55)]",
+  emerald: "from-emerald-300 via-emerald-600 to-emerald-800 text-white shadow-[0_10px_30px_-10px_rgba(16,185,129,0.55)]",
+  sky: "from-sky-300 via-sky-600 to-sky-800 text-white shadow-[0_10px_30px_-10px_rgba(14,165,233,0.55)]",
+  amber: "from-amber-300 via-amber-500 to-amber-700 text-black shadow-[0_10px_30px_-10px_rgba(245,158,11,0.55)]",
+  white: "from-white via-white to-neutral-200 text-black shadow-[0_10px_30px_-10px_rgba(255,255,255,0.35)]",
+  graphite: "from-neutral-700 via-neutral-800 to-neutral-950 text-white shadow-[0_10px_30px_-10px_rgba(0,0,0,0.55)]",
+};
+
+export function WensityButton({
+  children,
+  size = "md",
+  tone = "chili",
+  showArrow = true,
+  className,
+  href,
+  external,
+  disabled,
+  ...props
+}: ButtonProps | AnchorProps) {
+  const classes = cn(
+    "group relative inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-xl bg-gradient-to-b font-medium transition-[box-shadow,background-color,color,border-color,opacity] duration-200 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-chili-500 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
+    sizes[size],
+    tones[tone],
+    disabled && "pointer-events-none opacity-60",
+    className
+  );
+  const content = (
+    <>
+      <span className="relative z-10 inline-flex items-center gap-2">{children}</span>
+      {showArrow && <span aria-hidden className="relative z-10">-&gt;</span>}
+      <span aria-hidden className="pointer-events-none absolute inset-0 overflow-hidden rounded-xl">
+        <span className="absolute inset-x-0 top-0 h-px bg-gradient-to-r from-transparent via-white/40 to-transparent" />
+      </span>
+    </>
+  );
+
+  if (href && !disabled) {
+    return (
+      <a
+        href={href}
+        target={external || /^(https?:|mailto:|tel:)/i.test(href) ? "_blank" : undefined}
+        rel={external || /^(https?:|mailto:|tel:)/i.test(href) ? "noreferrer" : undefined}
+        className={classes}
+        {...(props as React.AnchorHTMLAttributes<HTMLAnchorElement>)}
+      >
+        {content}
+      </a>
+    );
+  }
+
+  return (
+    <button
+      type="button"
+      className={classes}
+      disabled={disabled}
+      {...(props as React.ButtonHTMLAttributes<HTMLButtonElement>)}
+    >
+      {content}
+    </button>
+  );
+}
+
+export function WensitySecondaryButton({
+  children,
+  size = "md",
+  showArrow = false,
+  className,
+  href,
+  external,
+  disabled,
+  ...props
+}: ButtonProps | AnchorProps) {
+  const classes = cn(
+    "group relative inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-xl border border-black/10 bg-white font-semibold text-neutral-950 shadow-[0_8px_24px_-18px_rgba(15,23,42,0.35)] transition-[box-shadow,background-color,color,border-color,opacity] duration-200 hover:border-black/15 hover:bg-neutral-50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-chili-500 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 dark:border-white/10 dark:bg-white/[0.06] dark:text-white dark:hover:border-white/15 dark:hover:bg-white/[0.09]",
+    sizes[size],
+    disabled && "pointer-events-none opacity-60",
+    className
+  );
+  const content = (
+    <>
+      <span className="relative z-10 inline-flex items-center gap-2">{children}</span>
+      {showArrow && <span aria-hidden className="relative z-10">-&gt;</span>}
+    </>
+  );
+
+  if (href && !disabled) {
+    return (
+      <a
+        href={href}
+        target={external || /^(https?:|mailto:|tel:)/i.test(href) ? "_blank" : undefined}
+        rel={external || /^(https?:|mailto:|tel:)/i.test(href) ? "noreferrer" : undefined}
+        className={classes}
+        {...(props as React.AnchorHTMLAttributes<HTMLAnchorElement>)}
+      >
+        {content}
+      </a>
+    );
+  }
+
+  return (
+    <button
+      type="button"
+      className={classes}
+      disabled={disabled}
+      {...(props as React.ButtonHTMLAttributes<HTMLButtonElement>)}
+    >
+      {content}
+    </button>
+  );
+}
+`;
+}
+
+// src/component-install.ts
+var ALWAYS_PRESENT_PACKAGES = /* @__PURE__ */ new Set(["react", "react-dom", "next"]);
+async function prepareInstall(projectRoot, config, payload) {
+  const fallbackFileName = componentFileName(payload.slug);
+  const files = [];
+  const componentContents = [];
+  let needsUtility = false;
+  let needsPrimitives = false;
+  for (const payloadFile of payload.files) {
+    const safePayloadPath = sanitizePayloadPath(payloadFile.path, fallbackFileName);
+    const relativeOutputPath = toPosixPath(join5(config.components, safePayloadPath));
+    const transformed = transformComponentSource(payloadFile.content, config);
+    needsUtility ||= transformed.needsUtility || transformed.needsPrimitives;
+    needsPrimitives ||= transformed.needsPrimitives;
+    componentContents.push(transformed.content);
+    files.push({
+      absolutePath: resolveInside(projectRoot, relativeOutputPath),
+      relativePath: relativeOutputPath,
+      content: transformed.content,
+      kind: "component"
+    });
+  }
+  if (needsUtility) {
+    const utilityPath = withSourceExtension(config.utils, "ts");
+    if (!await fileExists(resolveInside(projectRoot, utilityPath))) {
+      files.push({
+        absolutePath: resolveInside(projectRoot, utilityPath),
+        relativePath: utilityPath,
+        content: cnUtilityTemplate(),
+        kind: "helper"
+      });
+    }
+  }
+  if (needsPrimitives) {
+    const primitivesPath = toPosixPath(join5(config.components, "primitives.tsx"));
+    if (!await fileExists(resolveInside(projectRoot, primitivesPath))) {
+      const primitives = primitivesTemplate(config.aliases.utils);
+      files.push({
+        absolutePath: resolveInside(projectRoot, primitivesPath),
+        relativePath: primitivesPath,
+        content: primitives,
+        kind: "helper"
+      });
+      componentContents.push(primitives);
+    }
+  }
+  const dependencies = collectDependencies({
+    declared: payload.dependencies ?? [],
+    source: componentContents.join("\n"),
+    needsUtility
+  });
+  return { files, dependencies };
+}
+async function assertNoConflicts(files, force) {
+  if (force) return;
+  const conflicts = [];
+  for (const file of files) {
+    if (await fileExists(file.absolutePath)) conflicts.push(file.relativePath);
+  }
+  if (conflicts.length > 0) {
+    throw new CliError(`Refusing to overwrite existing files. Use --force to replace:
+${conflicts.map((path) => `  - ${path}`).join("\n")}`);
+  }
+}
+async function writePlannedFiles(files) {
+  for (const file of files) {
+    await mkdir3(dirname4(file.absolutePath), { recursive: true });
+    await writeFile3(file.absolutePath, file.content, "utf8");
+  }
+}
+function summarizeFiles(projectRoot, files) {
+  return files.map((file) => toPosixPath(relative3(projectRoot, file.absolutePath)));
+}
+function transformComponentSource(content, config) {
+  const needsUtility = content.includes("@wensity/ui/lib");
+  const needsPrimitives = content.includes("@wensity/ui/components");
+  let transformed = content;
+  transformed = transformed.replace(/from\s+["']@wensity\/ui\/lib["']/g, `from "${config.aliases.utils}"`);
+  transformed = transformed.replace(/from\s+["']@wensity\/ui\/components["']/g, `from "${config.aliases.components}/primitives"`);
+  return { content: transformed, needsUtility, needsPrimitives };
+}
+function collectDependencies(input) {
+  const dependencies = /* @__PURE__ */ new Set();
+  for (const dependency of input.declared) {
+    const normalized = normalizePackageName(dependency);
+    if (normalized) dependencies.add(normalized);
+  }
+  for (const dependency of parseImports(input.source)) {
+    const normalized = normalizePackageName(dependency);
+    if (normalized) dependencies.add(normalized);
+  }
+  if (input.needsUtility) {
+    dependencies.add("clsx");
+    dependencies.add("tailwind-merge");
+  }
+  return [...dependencies].sort();
+}
+function parseImports(source) {
+  const imports = [];
+  const patterns = [
+    /(?:import|export)\s+(?:type\s+)?(?:[\s\S]*?\s+from\s*)?["']([^"']+)["']/g,
+    /import\(\s*["']([^"']+)["']\s*\)/g
+  ];
+  for (const pattern of patterns) {
+    for (const match of source.matchAll(pattern)) {
+      if (match[1]) imports.push(match[1]);
+    }
+  }
+  return imports;
+}
+function normalizePackageName(specifier) {
+  if (!specifier || specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("@/")) {
+    return void 0;
+  }
+  if (specifier.startsWith("@wensity/ui")) return void 0;
+  const packageName = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+  if (ALWAYS_PRESENT_PACKAGES.has(packageName)) return void 0;
+  if (packageName.startsWith("node:")) return void 0;
+  return packageName;
+}
+function withSourceExtension(path, extension) {
+  const directory = parentDirectory(path);
+  const fileName = extensionlessPath(path.split("/").at(-1) ?? path);
+  return toPosixPath(join5(directory === "." ? "" : directory, `${fileName}.${extension}`));
+}
+
+// src/commands.ts
+async function run(context) {
+  const parsed = parseArgs(context.argv);
+  if (hasFlag(parsed, "version")) {
+    print(CLI_VERSION);
+    return;
+  }
+  if (hasFlag(parsed, "help") || parsed.positionals.length === 0) {
+    print(HELP_TEXT.trimEnd());
+    return;
+  }
+  const [command, ...positionals] = parsed.positionals;
+  switch (command) {
+    case "init":
+      await initCommand(context, parsed);
+      return;
+    case "login":
+      await loginCommand(context, parsed);
+      return;
+    case "logout":
+      await logoutCommand(context);
+      return;
+    case "whoami":
+      await whoamiCommand(context, parsed);
+      return;
+    case "list":
+      await listCommand(context, parsed);
+      return;
+    case "add":
+      await addCommand(context, parsed, positionals, false);
+      return;
+    case "update":
+      await addCommand(context, parsed, positionals, true);
+      return;
+    case "version":
+      print(CLI_VERSION);
+      return;
+    default:
+      throw new CliError(`Unknown command: ${command}
+
+${HELP_TEXT.trimEnd()}`);
+  }
+}
+async function initCommand(context, parsed) {
+  const dryRun = hasFlag(parsed, "dry-run");
+  const force = hasFlag(parsed, "force");
+  const install = !hasFlag(parsed, "no-install");
+  const apiUrl = getStringOption(parsed, "api-url") ?? context.env.WENSITY_API_URL ?? DEFAULT_API_ORIGIN;
+  const config = createDefaultConfig(context.cwd, apiUrl);
+  const configPath = join6(context.cwd, CONFIG_FILE_NAME);
+  const utilityPath = resolveConfiguredFilePath(context.cwd, config.utils);
+  const utilityRelativePath = toPosixPath(config.utils.endsWith(".ts") ? config.utils : `${config.utils}.ts`);
+  const dependencies = ["clsx", "tailwind-merge"];
+  if (dryRun) {
+    print("Would write:");
+    print(formatList([CONFIG_FILE_NAME, utilityRelativePath]));
+    if (install) print(`Would install: ${dependencies.join(" ")}`);
+    return;
+  }
+  await writeConfigFile(configPath, config, force);
+  if (force || !await fileExists(utilityPath)) {
+    await writeTextFile(utilityPath, cnUtilityTemplate());
+  }
+  if (install) {
+    runInstall(context.cwd, missingDependencies(context.cwd, dependencies));
+  }
+  print("Created wensity.json and local Wensity helper files.");
+}
+async function loginCommand(context, parsed) {
+  const apiUrl = getStringOption(parsed, "api-url") ?? context.env.WENSITY_API_URL ?? DEFAULT_API_ORIGIN;
+  const apiBaseUrl = normalizeUrlOrigin(apiUrl);
+  const providedToken = getStringOption(parsed, "token") ?? context.env.WENSITY_TOKEN;
+  const token = providedToken ?? await readTokenInteractively();
+  if (!token) {
+    throw new CliError("A token is required. Create one in the Wensity dashboard and run wensity login again.");
+  }
+  const whoami = await requestJson(joinUrl(apiBaseUrl, "/api/cli/whoami"), { token });
+  const path = await writeCredentials(context.env, {
+    version: 1,
+    apiBaseUrl,
+    token,
+    user: whoami.user,
+    plan: whoami.plan,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  print(`Logged in as ${whoami.user.email}.`);
+  print(`Credentials saved to ${path}.`);
+}
+async function logoutCommand(context) {
+  const removed = await deleteCredentials(context.env);
+  print(removed ? "Logged out of Wensity." : "No Wensity credentials were stored.");
+}
+async function whoamiCommand(context, parsed) {
+  const credentials = await requireCredentials(context.env);
+  const whoami = await requestJson(joinUrl(credentials.apiBaseUrl, "/api/cli/whoami"), {
+    token: credentials.token
+  });
+  if (hasFlag(parsed, "json")) {
+    printJson({ ...whoami, apiBaseUrl: credentials.apiBaseUrl, credentialsPath: credentialsPath(context.env) });
+    return;
+  }
+  print(`Signed in as ${whoami.user.email}`);
+  if (whoami.plan?.tier) {
+    print(`Plan: ${whoami.plan.tier}${whoami.plan.status ? ` (${whoami.plan.status})` : ""}`);
+  }
+}
+async function listCommand(context, parsed) {
+  const apiUrl = getStringOption(parsed, "api-url") ?? context.env.WENSITY_API_URL;
+  const registryOverride = getStringOption(parsed, "registry");
+  const loaded = await loadConfig(context.cwd, { registry: registryOverride, apiUrl });
+  const response = await requestJson(loaded.config.registry);
+  if (hasFlag(parsed, "json")) {
+    printJson(response);
+    return;
+  }
+  if (response.components.length === 0) {
+    print("No registry components found.");
+    return;
+  }
+  print("Available Wensity components:");
+  print(formatComponentGroup("Free", response.components.filter((component) => component.access !== "pro")));
+  print(formatComponentGroup("Pro", response.components.filter((component) => component.access === "pro")));
+}
+function formatComponentGroup(label, components) {
+  const rows = components.map((component) => {
+    const category = component.category ? ` ${component.category}` : "";
+    return `  ${component.slug.padEnd(32)}${category}`;
+  });
+  return rows.length > 0 ? `
+${label}
+${rows.join("\n")}` : `
+${label}
+  No components`;
+}
+async function addCommand(context, parsed, positionals, updateMode) {
+  const slug = positionals[0];
+  if (!slug) throw new CliError(`Missing component slug.
+
+Usage: wensity ${updateMode ? "update" : "add"} <slug>`);
+  const apiUrl = getStringOption(parsed, "api-url") ?? context.env.WENSITY_API_URL;
+  const registryOverride = getStringOption(parsed, "registry");
+  const loaded = await loadConfig(context.cwd, { registry: registryOverride, apiUrl });
+  const credentials = await readCredentials(context.env);
+  const payload = await fetchComponentPayload({ slug, registry: loaded.config.registry, credentials });
+  const prepared = await prepareInstall(loaded.projectRoot, loaded.config, payload);
+  const force = updateMode || hasFlag(parsed, "force");
+  const dryRun = hasFlag(parsed, "dry-run");
+  const install = !hasFlag(parsed, "no-install");
+  await assertNoConflicts(prepared.files, force || dryRun);
+  const plannedFiles = summarizeFiles(loaded.projectRoot, prepared.files);
+  const missing = missingDependencies(loaded.projectRoot, prepared.dependencies);
+  if (dryRun) {
+    print("Would write:");
+    print(formatList(plannedFiles));
+    if (install && missing.length > 0) print(`Would install: ${missing.join(" ")}`);
+    return;
+  }
+  await writePlannedFiles(prepared.files);
+  if (install) {
+    runInstall(loaded.projectRoot, missing);
+  }
+  print(`${updateMode ? "Updated" : "Added"} ${payload.name}.`);
+  print("Files written:");
+  print(formatList(plannedFiles));
+  if (!install && missing.length > 0) {
+    warn(`Dependencies were not installed: ${missing.join(" ")}`);
+  }
+}
+async function fetchComponentPayload(input) {
+  info(`Fetching ${input.slug}...`);
+  const metadata = await requestJson(registryMetadataUrl(input.registry, input.slug));
+  if (input.credentials) {
+    const cliEndpoint = metadata.endpoints?.cli ?? `/api/cli/${input.slug}`;
+    const endpoint2 = cliEndpoint.startsWith("http") ? cliEndpoint : joinUrl(input.credentials.apiBaseUrl, cliEndpoint);
+    return requestJson(endpoint2, { token: input.credentials.token });
+  }
+  if (metadata.access === "pro") {
+    throw new CliError(`${metadata.name} is a premium component. Run wensity login, then try again.`);
+  }
+  const publicSourceEndpoint = metadata.endpoints?.registry ?? registrySlugUrl(input.registry, input.slug);
+  const endpoint = publicSourceEndpoint.startsWith("http") ? publicSourceEndpoint : joinUrl(registryOrigin(input.registry), publicSourceEndpoint);
+  return requestJson(endpoint);
+}
+async function requireCredentials(env) {
+  const credentials = await readCredentials(env);
+  if (!credentials) {
+    throw new CliError("Not logged in. Run wensity login with an API token from the Wensity dashboard.");
+  }
+  return credentials;
+}
+function registryMetadataUrl(registry, slug) {
+  const url = new URL(registry);
+  url.searchParams.set("slug", slug);
+  return url.toString();
+}
+function registrySlugUrl(registry, slug) {
+  return joinUrl(registry.endsWith("/") ? registry : `${registry}/`, slug);
+}
+function registryOrigin(registry) {
+  const url = new URL(registry);
+  return `${url.protocol}//${url.host}`;
+}
+async function writeTextFile(path, content) {
+  await mkdir4(dirname5(path), { recursive: true });
+  await writeFile4(path, content, "utf8");
+}
+
+// src/index.ts
+run({
+  argv: process.argv.slice(2),
+  cwd: process.cwd(),
+  env: process.env
+}).catch((error) => {
+  if (error instanceof CliError) {
+    process.stderr.write(`${error.message}
+`);
+    process.exitCode = error.exitCode;
+    return;
+  }
+  const message = error instanceof Error ? error.stack ?? error.message : String(error);
+  process.stderr.write(`${message}
+`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "wensity",
+  "version": "0.1.0",
+  "description": "Wensity component registry CLI",
+  "type": "module",
+  "bin": {
+    "wensity": "dist/index.js"
+  },
+  "exports": {
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --platform node --target node20 --clean",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo 'no lint'"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}