vectorvesper 0.1.0

package/dist/index.js

@@ -0,0 +1,1162 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var verboseMode = false;
+function setVerbose(enabled) {
+  verboseMode = enabled;
+}
+var logger = {
+  /** Standard info message */
+  info(message) {
+    console.log(message);
+  },
+  /** Success message with green checkmark */
+  success(message) {
+    console.log(`${pc.green("\u2714")} ${message}`);
+  },
+  /** Warning message */
+  warn(message) {
+    console.log(pc.yellow(`\u26A0\uFE0F  ${message}`));
+  },
+  /** Error message */
+  error(message) {
+    console.error(pc.red(`\u274C ${message}`));
+  },
+  /** Debug message — only shown when --verbose is active */
+  debug(message) {
+    if (verboseMode) {
+      console.log(pc.dim(`  [debug] ${message}`));
+    }
+  },
+  /** Blank line */
+  break() {
+    console.log("");
+  }
+};
+
+// src/commands/init.ts
+import { intro, outro, select, text, confirm, isCancel } from "@clack/prompts";
+import pc2 from "picocolors";
+import fs3 from "fs";
+import path3 from "path";
+
+// src/utils/project.ts
+import fs from "fs";
+import path from "path";
+function detectProject(cwd = process.cwd()) {
+  const rootPath = cwd;
+  let packageManager = "npm";
+  if (fs.existsSync(path.join(rootPath, "pnpm-lock.yaml"))) {
+    packageManager = "pnpm";
+  } else if (fs.existsSync(path.join(rootPath, "yarn.lock"))) {
+    packageManager = "yarn";
+  } else if (fs.existsSync(path.join(rootPath, "bun.lockb")) || fs.existsSync(path.join(rootPath, "bun.lock"))) {
+    packageManager = "bun";
+  }
+  const isTypeScript = fs.existsSync(path.join(rootPath, "tsconfig.json"));
+  const hasSrcDir = fs.existsSync(path.join(rootPath, "src"));
+  const tailwindConfigs = [
+    "tailwind.config.js",
+    "tailwind.config.ts",
+    "tailwind.config.cjs",
+    "tailwind.config.mjs"
+  ];
+  const hasTailwind = tailwindConfigs.some(
+    (config) => fs.existsSync(path.join(rootPath, config))
+  );
+  let framework = "unknown";
+  let nextRouter;
+  const pkgPath = path.join(rootPath, "package.json");
+  let dependencies = {};
+  let devDependencies = {};
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      dependencies = pkg.dependencies || {};
+      devDependencies = pkg.devDependencies || {};
+    } catch (e) {
+    }
+  }
+  if (dependencies["next"] || devDependencies["next"]) {
+    framework = "next";
+    const searchPath = hasSrcDir ? path.join(rootPath, "src") : rootPath;
+    if (fs.existsSync(path.join(searchPath, "app"))) {
+      nextRouter = "app";
+    } else if (fs.existsSync(path.join(searchPath, "pages"))) {
+      nextRouter = "pages";
+    } else {
+      nextRouter = "app";
+    }
+  } else if (dependencies["vite"] || devDependencies["vite"] || fs.existsSync(path.join(rootPath, "vite.config.ts")) || fs.existsSync(path.join(rootPath, "vite.config.js"))) {
+    framework = "vite";
+  }
+  return {
+    packageManager,
+    isTypeScript,
+    framework,
+    nextRouter,
+    hasSrcDir,
+    hasTailwind,
+    rootPath
+  };
+}
+
+// src/utils/config.ts
+import fs2 from "fs";
+import path2 from "path";
+import os from "os";
+
+// src/utils/types.ts
+import { z } from "zod";
+var SLUG_REGEX = /^[a-z0-9][a-z0-9-]*$/;
+function validateSlug(slug) {
+  if (!SLUG_REGEX.test(slug)) {
+    throw new Error(
+      `Invalid component slug "${slug}". Slugs must contain only lowercase letters, numbers, and hyphens, and cannot start with a hyphen.`
+    );
+  }
+}
+var ComponentFileSchema = z.object({
+  path: z.string(),
+  target: z.string(),
+  type: z.enum(["component", "types", "shader", "lib", "docs"]),
+  content: z.string()
+});
+var RegistryComponentSchema = z.object({
+  slug: z.string(),
+  name: z.string(),
+  title: z.string(),
+  description: z.string(),
+  version: z.string(),
+  tier: z.enum(["free", "pro"]),
+  category: z.string(),
+  type: z.string(),
+  frameworks: z.array(z.string()),
+  files: z.array(ComponentFileSchema),
+  dependencies: z.array(z.string()),
+  devDependencies: z.array(z.string()),
+  registryDependencies: z.array(z.string()),
+  requiresClient: z.boolean(),
+  supportsReducedMotion: z.boolean(),
+  usesWebGL: z.boolean(),
+  usesPointer: z.boolean(),
+  usesScroll: z.boolean()
+}).passthrough();
+var IndexComponentSchema = z.object({
+  slug: z.string(),
+  name: z.string(),
+  title: z.string(),
+  description: z.string(),
+  version: z.string(),
+  tier: z.enum(["free", "pro"]),
+  category: z.string(),
+  type: z.string(),
+  frameworks: z.array(z.string()),
+  files: z.array(z.object({
+    path: z.string(),
+    target: z.string(),
+    type: z.enum(["component", "types", "shader", "lib", "docs"])
+  })),
+  dependencies: z.array(z.string()),
+  devDependencies: z.array(z.string()),
+  registryDependencies: z.array(z.string()),
+  requiresClient: z.boolean(),
+  supportsReducedMotion: z.boolean(),
+  usesWebGL: z.boolean(),
+  usesPointer: z.boolean(),
+  usesScroll: z.boolean()
+}).passthrough();
+var RegistryIndexSchema = z.object({
+  version: z.string(),
+  components: z.array(IndexComponentSchema)
+});
+var VVConfigSchema = z.object({
+  tsx: z.boolean(),
+  framework: z.enum(["next", "vite", "unknown"]),
+  aliases: z.object({
+    vv: z.string()
+  })
+});
+var VVGlobalConfigSchema = z.object({
+  // Auth — license key for paid components
+  auth: z.object({
+    token: z.string().optional(),
+    email: z.string().optional(),
+    tier: z.enum(["free", "pro", "team"]).optional(),
+    expiresAt: z.string().optional()
+  }).optional(),
+  // Preferences
+  telemetry: z.boolean().optional()
+}).passthrough();
+var ManifestEntrySchema = z.object({
+  version: z.string(),
+  installedAt: z.string(),
+  installedOn: z.string(),
+  files: z.array(z.string())
+});
+var ManifestSchema = z.object({
+  components: z.record(z.string(), ManifestEntrySchema)
+});
+
+// src/utils/config.ts
+var CONFIG_FILE_NAME = "vv.config.json";
+function getConfigPath(cwd = process.cwd()) {
+  return path2.join(cwd, CONFIG_FILE_NAME);
+}
+function loadConfig(cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  if (!fs2.existsSync(configPath)) {
+    return null;
+  }
+  let raw;
+  try {
+    const content = fs2.readFileSync(configPath, "utf-8");
+    raw = JSON.parse(content);
+  } catch {
+    throw new Error(
+      `Failed to parse vv.config.json \u2014 the file contains invalid JSON. Delete it and run "vv init" to regenerate.`
+    );
+  }
+  const result = VVConfigSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(
+      `Invalid vv.config.json \u2014 schema validation failed:
+${issues}
+Delete the file and run "vv init" to regenerate.`
+    );
+  }
+  return result.data;
+}
+function writeConfig(config, cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  fs2.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+var GLOBAL_CONFIG_DIR = path2.join(os.homedir(), ".vv");
+var GLOBAL_CONFIG_PATH = path2.join(GLOBAL_CONFIG_DIR, "config.json");
+function getGlobalConfigPath() {
+  return GLOBAL_CONFIG_PATH;
+}
+function loadGlobalConfig() {
+  if (!fs2.existsSync(GLOBAL_CONFIG_PATH)) {
+    return {};
+  }
+  try {
+    const content = fs2.readFileSync(GLOBAL_CONFIG_PATH, "utf-8");
+    const raw = JSON.parse(content);
+    const result = VVGlobalConfigSchema.safeParse(raw);
+    if (!result.success) {
+      logger.debug(`Global config validation failed: ${result.error.message}`);
+      return {};
+    }
+    return result.data;
+  } catch {
+    logger.debug("Failed to parse global config, using defaults.");
+    return {};
+  }
+}
+function saveGlobalConfig(config) {
+  if (!fs2.existsSync(GLOBAL_CONFIG_DIR)) {
+    fs2.mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+  }
+  fs2.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+function getAuthToken() {
+  const config = loadGlobalConfig();
+  return config.auth?.token;
+}
+function resolveAlias(alias, hasSrcDir) {
+  if (alias.startsWith("@/")) {
+    return alias.replace("@/", hasSrcDir ? "src/" : "");
+  }
+  if (alias.startsWith("~/")) {
+    return alias.replace("~/", hasSrcDir ? "src/" : "");
+  }
+  return alias;
+}
+
+// src/commands/init.ts
+async function initCommand(options = {}) {
+  console.log("");
+  intro(pc2.cyan(pc2.bold("  Vector Vesper Setup  ")));
+  const projectInfo = detectProject();
+  let tsx = projectInfo.isTypeScript;
+  let framework = projectInfo.framework;
+  let aliasInput = "@/components/vv";
+  if (!options.yes) {
+    try {
+      const existingConfig = loadConfig();
+      if (existingConfig) {
+        const shouldOverwrite = await confirm({
+          message: pc2.yellow("vv.config.json already exists. Overwrite it?"),
+          initialValue: false
+        });
+        if (isCancel(shouldOverwrite) || !shouldOverwrite) {
+          outro(pc2.red("Setup cancelled."));
+          return;
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(pc2.yellow(`
+  \u26A0\uFE0F  ${message}
+`));
+      const shouldReplace = await confirm({
+        message: pc2.yellow("Replace the corrupted config?"),
+        initialValue: true
+      });
+      if (isCancel(shouldReplace) || !shouldReplace) {
+        outro(pc2.red("Setup cancelled."));
+        return;
+      }
+    }
+    const tsxResponse = await confirm({
+      message: `Use TypeScript? ${pc2.dim(`(Detected: ${projectInfo.isTypeScript ? "Yes" : "No"})`)}`,
+      initialValue: projectInfo.isTypeScript
+    });
+    if (isCancel(tsxResponse)) {
+      outro(pc2.red("Setup cancelled."));
+      return;
+    }
+    tsx = tsxResponse;
+    const frameworkResponse = await select({
+      message: `Configure your framework: ${pc2.dim(`(Detected: ${projectInfo.framework})`)}`,
+      options: [
+        { value: "next", label: "Next.js" },
+        { value: "vite", label: "Vite" },
+        { value: "unknown", label: "Other / Manual configuration" }
+      ],
+      initialValue: projectInfo.framework
+    });
+    if (isCancel(frameworkResponse)) {
+      outro(pc2.red("Setup cancelled."));
+      return;
+    }
+    framework = frameworkResponse;
+    const defaultAlias = "@/components/vv";
+    const aliasResponse = await text({
+      message: "Configure components import alias:",
+      placeholder: defaultAlias,
+      defaultValue: defaultAlias,
+      validate(value) {
+        if (!value.startsWith("@/") && !value.startsWith("~/") && !value.startsWith("src/")) {
+          return "Alias must start with '@/', '~/', or 'src/'";
+        }
+      }
+    });
+    if (isCancel(aliasResponse)) {
+      outro(pc2.red("Setup cancelled."));
+      return;
+    }
+    aliasInput = aliasResponse;
+  } else {
+    console.log(pc2.dim(`  \u26A1 Running in non-interactive mode (-y)`));
+    console.log(pc2.dim(`  \u2022 TypeScript: ${tsx ? "Yes" : "No"}`));
+    console.log(pc2.dim(`  \u2022 Framework: ${framework}`));
+    console.log(pc2.dim(`  \u2022 Components Alias: ${aliasInput}`));
+  }
+  const config = {
+    tsx,
+    framework,
+    aliases: {
+      vv: aliasInput
+    }
+  };
+  try {
+    writeConfig(config);
+    const targetLocalDir = resolveAlias(aliasInput, projectInfo.hasSrcDir);
+    const absoluteTargetDir = path3.join(process.cwd(), targetLocalDir);
+    if (!fs3.existsSync(absoluteTargetDir)) {
+      fs3.mkdirSync(absoluteTargetDir, { recursive: true });
+    }
+    const manifestPath = path3.join(process.cwd(), "vv-manifest.json");
+    if (!fs3.existsSync(manifestPath)) {
+      fs3.writeFileSync(manifestPath, JSON.stringify({ components: {} }, null, 2), "utf-8");
+    }
+    console.log("");
+    outro(
+      `${pc2.green(pc2.bold("\u2714 Success!"))} Vector Vesper initialized.
+
+  \u2022 Configuration written to ${pc2.cyan("vv.config.json")}
+  \u2022 Target directory created at ${pc2.cyan(targetLocalDir)}
+  \u2022 Manifest created at ${pc2.cyan("vv-manifest.json")}
+
+  \u{1F449} Next, run: ${pc2.bold(pc2.cyan("vv add <slug>"))} to add a component.`
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    outro(pc2.red(`Failed to initialize: ${message}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/list.ts
+import pc3 from "picocolors";
+import ora from "ora";
+
+// src/utils/registry.ts
+import fs4 from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/vectorvesper/vv-components/main/r";
+var FETCH_TIMEOUT_MS = 15e3;
+var MAX_RETRIES = 1;
+var RETRY_DELAY_MS = 1e3;
+function getRegistryBaseUrl() {
+  return process.env.VV_REGISTRY_URL || DEFAULT_REGISTRY_URL;
+}
+function handleHttpError(status, url) {
+  switch (status) {
+    case 401:
+      throw new Error(
+        `Authentication required. This component requires a valid license key.
+\u{1F449} Run "vv login <your-license-key>" to authenticate.
+\u{1F511} Get a license at https://vectorvesper.dev/pricing`
+      );
+    case 402:
+      throw new Error(
+        `This is a Pro component and requires an active subscription.
+\u{1F449} Upgrade at https://vectorvesper.dev/pricing
+\u{1F4A1} Run "vv list" to see all free components.`
+      );
+    case 403:
+      throw new Error(
+        `Access denied. Your license may have expired or doesn't include this component.
+\u{1F449} Check your account at https://vectorvesper.dev/account
+\u{1F4A1} Run "vv whoami" to see your current plan.`
+      );
+    case 404:
+      throw new Error(
+        `Component not found in the registry.
+\u{1F449} Run "vv list" to see all available components.`
+      );
+    case 429:
+      throw new Error(
+        `Rate limited by the registry. Please wait a moment and try again.`
+      );
+    default:
+      throw new Error(
+        `Registry request failed: HTTP ${status}
+URL: ${url}`
+      );
+  }
+}
+async function fetchWithRetry(url) {
+  const token = getAuthToken();
+  const headers = {
+    "User-Agent": "vv-cli",
+    "Accept": "application/json"
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+    logger.debug(`Using auth token for request`);
+  }
+  let lastError = null;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      if (attempt > 0) {
+        logger.debug(`Retry attempt ${attempt} for ${url}`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS * attempt));
+      }
+      logger.debug(`Fetching: ${url}`);
+      const response = await fetch(url, {
+        headers,
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        if (response.status >= 400 && response.status < 500) {
+          handleHttpError(response.status, url);
+        }
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return await response.text();
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes("Authentication required") || error.message.includes("Pro component") || error.message.includes("Access denied") || error.message.includes("not found in the registry")) {
+          throw error;
+        }
+        if (error.name === "TimeoutError" || error.name === "AbortError") {
+          lastError = new Error(
+            `Request timed out after ${FETCH_TIMEOUT_MS / 1e3}s. Check your internet connection or try again.`
+          );
+          continue;
+        }
+        lastError = error;
+      } else {
+        lastError = new Error(String(error));
+      }
+    }
+  }
+  throw lastError || new Error(`Failed to fetch: ${url}`);
+}
+async function fetchRegistryData(urlOrPath) {
+  if (urlOrPath.startsWith("http://") || urlOrPath.startsWith("https://")) {
+    if (urlOrPath.startsWith("http://") && !urlOrPath.includes("localhost") && !urlOrPath.includes("127.0.0.1")) {
+      logger.warn("Using insecure HTTP for registry. Consider switching to HTTPS.");
+    }
+    return fetchWithRetry(urlOrPath);
+  }
+  let cleanPath = urlOrPath;
+  if (urlOrPath.startsWith("file://")) {
+    cleanPath = fileURLToPath(urlOrPath);
+  }
+  cleanPath = path4.resolve(cleanPath);
+  if (!fs4.existsSync(cleanPath)) {
+    throw new Error(`Registry path not found: ${cleanPath}`);
+  }
+  logger.debug(`Reading local registry: ${cleanPath}`);
+  return fs4.readFileSync(cleanPath, "utf-8");
+}
+async function fetchRegistryIndex() {
+  const baseUrl = getRegistryBaseUrl();
+  const url = baseUrl.endsWith("/") ? `${baseUrl}registry.json` : `${baseUrl}/registry.json`;
+  const content = await fetchRegistryData(url);
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch {
+    throw new Error("Failed to parse registry index \u2014 received invalid JSON.");
+  }
+  const result = RegistryIndexSchema.safeParse(raw);
+  if (!result.success) {
+    logger.debug(`Registry index validation errors: ${result.error.message}`);
+    throw new Error("Registry index failed validation. The registry may be corrupted or incompatible with this CLI version.");
+  }
+  return result.data;
+}
+async function fetchComponent(slug) {
+  validateSlug(slug);
+  const baseUrl = getRegistryBaseUrl();
+  const url = baseUrl.endsWith("/") ? `${baseUrl}${slug}.json` : `${baseUrl}/${slug}.json`;
+  const content = await fetchRegistryData(url);
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch {
+    throw new Error(`Failed to parse component "${slug}" \u2014 received invalid JSON.`);
+  }
+  const result = RegistryComponentSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    logger.debug(`Component "${slug}" validation errors:
+${issues}`);
+    throw new Error(
+      `Component "${slug}" failed validation. This may indicate an incompatible registry version. Try updating the CLI.`
+    );
+  }
+  return result.data;
+}
+
+// src/commands/list.ts
+async function listCommand() {
+  const spinner = ora({
+    text: "Fetching components list...",
+    color: "cyan"
+  }).start();
+  try {
+    const registry = await fetchRegistryIndex();
+    spinner.succeed(pc3.green("Fetched components list successfully!\n"));
+    if (registry.components.length === 0) {
+      console.log(pc3.dim("  No components available in the registry yet."));
+      console.log(pc3.dim("  Check back soon or visit https://vectorvesper.dev\n"));
+      return;
+    }
+    const hasAuth = !!getAuthToken();
+    console.log(pc3.bold(pc3.white("Vector Vesper Available Components:")));
+    console.log(pc3.dim("--------------------------------------------------------------------------------"));
+    for (const c of registry.components) {
+      const slugCol = pc3.cyan(c.slug.padEnd(25));
+      const categoryCol = pc3.yellow(c.category.padEnd(15));
+      let tierBadge;
+      if (c.tier === "pro") {
+        tierBadge = hasAuth ? pc3.magenta("pro ") : pc3.dim("\u{1F512}  ");
+      } else {
+        tierBadge = pc3.green("free");
+      }
+      console.log(`${slugCol} [${tierBadge}]  ${categoryCol}  ${pc3.gray(c.description)}`);
+    }
+    console.log(pc3.dim("--------------------------------------------------------------------------------"));
+    const freeCount = registry.components.filter((c) => c.tier === "free").length;
+    const proCount = registry.components.filter((c) => c.tier === "pro").length;
+    console.log(`
+  ${pc3.green(String(freeCount))} free components${proCount > 0 ? ` \xB7 ${pc3.magenta(String(proCount))} pro components` : ""}`);
+    if (proCount > 0 && !hasAuth) {
+      console.log(`  \u{1F511} ${pc3.dim("Unlock pro components:")} ${pc3.cyan("vv login <key>")} ${pc3.dim("\xB7")} ${pc3.cyan("https://vectorvesper.dev/pricing")}`);
+    }
+    console.log(`
+\u{1F449} Run ${pc3.bold(pc3.cyan("vv add <slug>"))} to add a component to your project.
+`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    spinner.fail(pc3.red(`Failed to fetch components list: ${message}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/add.ts
+import fs5 from "fs";
+import path5 from "path";
+import ora2 from "ora";
+import pc4 from "picocolors";
+import { confirm as confirm2, isCancel as isCancel2 } from "@clack/prompts";
+function toForwardSlash(p) {
+  return p.replace(/\\/g, "/");
+}
+function reportMissingDependencies(resolvedComponents, projectRoot, projectInfo) {
+  const pkgPath = path5.join(projectRoot, "package.json");
+  if (!fs5.existsSync(pkgPath)) return;
+  try {
+    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+    const installedDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+      ...pkg.peerDependencies
+    };
+    const missingDeps = /* @__PURE__ */ new Set();
+    for (const component of resolvedComponents) {
+      if (component.dependencies) {
+        for (const dep of component.dependencies) {
+          if (!installedDeps[dep]) {
+            missingDeps.add(dep);
+          }
+        }
+      }
+    }
+    if (missingDeps.size > 0) {
+      console.log(pc4.yellow(`
+\u26A0\uFE0F  Missing peer dependencies in your project:`));
+      const pm = projectInfo.packageManager;
+      const depsStr = Array.from(missingDeps).join(" ");
+      const installCmd = pm === "pnpm" ? `pnpm add ${depsStr}` : pm === "yarn" ? `yarn add ${depsStr}` : pm === "bun" ? `bun add ${depsStr}` : `npm install ${depsStr}`;
+      console.log(`  Run: ${pc4.bold(pc4.cyan(installCmd))}`);
+    }
+  } catch {
+  }
+}
+async function addCommand(slug, options = {}) {
+  try {
+    validateSlug(slug);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${pc4.red(pc4.bold("Error:"))} ${message}`);
+    process.exit(1);
+  }
+  let config;
+  try {
+    config = loadConfig();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${pc4.red(pc4.bold("Error:"))} ${message}`);
+    process.exit(1);
+  }
+  if (!config) {
+    console.error(
+      `${pc4.red(pc4.bold("Error:"))} No ${pc4.cyan("vv.config.json")} found in this directory.
+\u{1F449} Run ${pc4.bold(pc4.cyan("vv init"))} first to set up your project.`
+    );
+    process.exit(1);
+    return;
+  }
+  const projectInfo = detectProject();
+  const componentInstallDir = resolveAlias(config.aliases.vv, projectInfo.hasSrcDir);
+  const spinner = ora2({
+    text: `Resolving component ${pc4.cyan(slug)}...`,
+    color: "cyan"
+  }).start();
+  const resolvedComponents = [];
+  const visited = /* @__PURE__ */ new Set();
+  async function resolveComponentTree(componentSlug, depth = 0) {
+    if (visited.has(componentSlug)) return;
+    if (depth > 20) {
+      throw new Error(`Dependency resolution exceeded maximum depth (20). Possible circular dependency involving "${componentSlug}".`);
+    }
+    visited.add(componentSlug);
+    const component = await fetchComponent(componentSlug);
+    if (component.tier === "pro" && !getAuthToken()) {
+      throw new Error(
+        `"${componentSlug}" is a Pro component and requires authentication.
+\u{1F449} Run ${pc4.cyan("vv login <your-license-key>")} to unlock pro components.
+\u{1F511} Get a key at ${pc4.cyan("https://vectorvesper.dev/pricing")}`
+      );
+    }
+    if (component.registryDependencies && component.registryDependencies.length > 0) {
+      for (const depSlug of component.registryDependencies) {
+        await resolveComponentTree(depSlug, depth + 1);
+      }
+    }
+    resolvedComponents.push(component);
+  }
+  try {
+    await resolveComponentTree(slug);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    spinner.fail(pc4.red(`Failed to resolve component "${slug}": ${message}`));
+    process.exit(1);
+  }
+  spinner.text = "Checking file conflicts...";
+  const filesToWrite = [];
+  const projectRoot = process.cwd();
+  for (const component of resolvedComponents) {
+    const compDir = path5.join(projectRoot, componentInstallDir);
+    for (const file of component.files) {
+      const fileWritePath = path5.resolve(compDir, file.target);
+      const relativeFromRoot = path5.relative(projectRoot, fileWritePath);
+      if (relativeFromRoot.startsWith("..") || path5.isAbsolute(relativeFromRoot)) {
+        spinner.fail(
+          `${pc4.red(pc4.bold("Security Error:"))} Component target file path tries to escape project root: ${file.target}`
+        );
+        process.exit(1);
+      }
+      if (fs5.existsSync(fileWritePath)) {
+        if (options.dryRun) {
+        } else if (!options.overwrite && !options.yes) {
+          spinner.stop();
+          const relativeDisplayPath = path5.relative(projectRoot, fileWritePath);
+          const shouldOverwrite = await confirm2({
+            message: pc4.yellow(`File already exists: "${relativeDisplayPath}". Overwrite?`),
+            initialValue: false
+          });
+          if (isCancel2(shouldOverwrite) || !shouldOverwrite) {
+            console.log(pc4.dim(`  Skipping existing file: ${relativeDisplayPath}`));
+            spinner.start("Continuing installation...");
+            continue;
+          }
+          spinner.start("Continuing installation...");
+        }
+      }
+      filesToWrite.push({
+        absolutePath: fileWritePath,
+        relativePath: relativeFromRoot,
+        content: file.content
+      });
+    }
+  }
+  if (options.dryRun) {
+    spinner.succeed(pc4.yellow("Dry-run: Simulation completed. No files were written."));
+    console.log(pc4.bold(pc4.yellow("\n[Dry Run] Files that would be created/modified:")));
+    for (const file of filesToWrite) {
+      const status = fs5.existsSync(file.absolutePath) ? pc4.yellow("(exists, would overwrite)") : pc4.green("(new)");
+      console.log(`  ${pc4.cyan(file.relativePath)} ${status}`);
+    }
+    reportMissingDependencies(resolvedComponents, projectRoot, projectInfo);
+    const targetComponent2 = resolvedComponents[resolvedComponents.length - 1];
+    console.log("");
+    console.log(
+      pc4.bold(pc4.yellow("\u2714 [Dry Run] Would add ")) + pc4.bold(pc4.cyan(targetComponent2.slug)) + pc4.bold(pc4.yellow(` to ${toForwardSlash(path5.join(componentInstallDir, targetComponent2.slug))}`))
+    );
+    console.log("");
+    console.log(pc4.gray("\u{1F449} Loving Vector Vesper? Star the repo: https://github.com/vectorvesper/vv-components"));
+    console.log(pc4.gray("\u{1F680} Need premium WebGL effects? Get the Pixel Library: https://vectorvesper.dev/library"));
+    console.log("");
+    return;
+  }
+  if (filesToWrite.length === 0) {
+    spinner.succeed(pc4.green("All files skipped (already up to date)."));
+    return;
+  }
+  spinner.text = "Writing component files...";
+  try {
+    for (const file of filesToWrite) {
+      const folder = path5.dirname(file.absolutePath);
+      if (!fs5.existsSync(folder)) {
+        fs5.mkdirSync(folder, { recursive: true });
+      }
+      fs5.writeFileSync(file.absolutePath, file.content, "utf-8");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    spinner.fail(pc4.red(`Failed to write files: ${message}`));
+    process.exit(1);
+  }
+  try {
+    const manifestPath = path5.join(projectRoot, "vv-manifest.json");
+    let manifest = { components: {} };
+    if (fs5.existsSync(manifestPath)) {
+      manifest = JSON.parse(fs5.readFileSync(manifestPath, "utf-8"));
+    }
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    for (const component of resolvedComponents) {
+      manifest.components[component.slug] = {
+        version: component.version,
+        installedAt: toForwardSlash(path5.join(componentInstallDir, component.slug)),
+        installedOn: today,
+        files: component.files.map((f) => f.target)
+      };
+    }
+    fs5.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`Failed to update vv-manifest.json: ${message}`);
+    logger.warn("Component was installed but may not appear in 'vv info' or 'vv diff'.");
+  }
+  spinner.succeed(pc4.green("Files written successfully!"));
+  console.log(pc4.dim("\nCreated files:"));
+  for (const file of filesToWrite) {
+    console.log(`  ${pc4.green("\u2714")} ${pc4.cyan(file.relativePath)}`);
+  }
+  reportMissingDependencies(resolvedComponents, projectRoot, projectInfo);
+  const targetComponent = resolvedComponents[resolvedComponents.length - 1];
+  console.log("");
+  console.log(
+    pc4.bold(pc4.green("\u2714 Added ")) + pc4.bold(pc4.cyan(targetComponent.slug)) + pc4.bold(pc4.green(` to ${toForwardSlash(path5.join(componentInstallDir, targetComponent.slug))}`))
+  );
+  console.log("");
+  console.log(pc4.gray("\u{1F449} Loving Vector Vesper? Star the repo: https://github.com/vectorvesper/vv-components"));
+  console.log(pc4.gray("\u{1F680} Need premium WebGL effects? Get the Pixel Library: https://vectorvesper.dev/library"));
+  console.log("");
+}
+
+// src/commands/info.ts
+import fs6 from "fs";
+import path6 from "path";
+import pc5 from "picocolors";
+var CLI_VERSION = true ? "0.1.0" : "0.0.0-dev";
+async function infoCommand() {
+  console.log(pc5.bold(pc5.cyan("\nVector Vesper Diagnostics\n")));
+  const projectInfo = detectProject();
+  let config;
+  try {
+    config = loadConfig();
+  } catch {
+    config = null;
+  }
+  console.log(pc5.bold(pc5.white("Environment:")));
+  console.log(`  \u2022 CLI Version:     ${pc5.cyan(CLI_VERSION)}`);
+  console.log(`  \u2022 Node Version:    ${pc5.cyan(process.version)}`);
+  console.log(`  \u2022 OS:              ${pc5.cyan(`${process.platform} ${process.arch}`)}`);
+  console.log(`  \u2022 Package Manager: ${pc5.cyan(projectInfo.packageManager)}`);
+  console.log(`  \u2022 Framework:       ${pc5.cyan(projectInfo.framework)}`);
+  console.log(`  \u2022 TypeScript:      ${pc5.cyan(projectInfo.isTypeScript ? "Yes" : "No")}`);
+  console.log(`  \u2022 Has src/ folder: ${pc5.cyan(projectInfo.hasSrcDir ? "Yes" : "No")}`);
+  console.log(`  \u2022 Tailwind CSS:    ${pc5.cyan(projectInfo.hasTailwind ? "Yes" : "No")}`);
+  console.log("");
+  console.log(pc5.bold(pc5.white("Authentication:")));
+  const token = getAuthToken();
+  if (token) {
+    const maskedKey = token.slice(0, 6) + "\u2026" + token.slice(-4);
+    console.log(`  \u2022 Status:          ${pc5.green("Authenticated")}`);
+    console.log(`  \u2022 Key:             ${pc5.cyan(maskedKey)}`);
+  } else {
+    console.log(`  \u2022 Status:          ${pc5.yellow("Anonymous (free tier)")}`);
+    console.log(`  ${pc5.dim("  Run")} ${pc5.cyan("vv login <key>")} ${pc5.dim("to unlock pro components")}`);
+  }
+  console.log("");
+  console.log(pc5.bold(pc5.white("Configuration (vv.config.json):")));
+  if (config) {
+    console.log(`  \u2022 Framework Set:   ${pc5.cyan(config.framework)}`);
+    console.log(`  \u2022 TypeScript Set:  ${pc5.cyan(config.tsx ? "Yes" : "No")}`);
+    console.log(`  \u2022 Component Alias: ${pc5.cyan(config.aliases.vv)}`);
+  } else {
+    console.log(`  ${pc5.yellow("\u26A0\uFE0F  No vv.config.json found in this directory.")}`);
+  }
+  console.log("");
+  console.log(pc5.bold(pc5.white("Installed Components (vv-manifest.json):")));
+  const manifestPath = path6.join(process.cwd(), "vv-manifest.json");
+  if (fs6.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(fs6.readFileSync(manifestPath, "utf-8"));
+      const components = manifest.components || {};
+      const slugs = Object.keys(components);
+      if (slugs.length === 0) {
+        console.log(`  ${pc5.dim("No components installed yet.")}`);
+      } else {
+        console.log(pc5.dim("  ------------------------------------------------------------"));
+        console.log(`  ${pc5.bold(pc5.white("Component".padEnd(25)))} ${pc5.bold(pc5.white("Version".padEnd(10)))} ${pc5.bold(pc5.white("Installed At"))}`);
+        console.log(pc5.dim("  ------------------------------------------------------------"));
+        for (const slug of slugs) {
+          const info = components[slug];
+          const version2 = info?.version ?? "unknown";
+          const installedAt = info?.installedAt ?? "unknown";
+          console.log(`  ${pc5.cyan(slug.padEnd(25))} ${pc5.green(version2.padEnd(10))} ${pc5.gray(installedAt)}`);
+        }
+        console.log(pc5.dim("  ------------------------------------------------------------"));
+      }
+    } catch {
+      console.log(`  ${pc5.red("\u274C Error reading vv-manifest.json: Invalid JSON format.")}`);
+    }
+  } else {
+    console.log(`  ${pc5.dim("No components installed yet (vv-manifest.json not found).")}`);
+  }
+  console.log("");
+}
+
+// src/commands/diff.ts
+import fs7 from "fs";
+import path7 from "path";
+import pc6 from "picocolors";
+import ora3 from "ora";
+async function diffCommand(slug) {
+  const projectRoot = process.cwd();
+  const manifestPath = path7.join(projectRoot, "vv-manifest.json");
+  if (!fs7.existsSync(manifestPath)) {
+    console.log(pc6.yellow(`
+\u26A0\uFE0F  No vv-manifest.json found in this directory.`));
+    console.log(`\u{1F449} Add components first using ${pc6.bold(pc6.cyan("vv add <slug>"))}
+`);
+    return;
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(fs7.readFileSync(manifestPath, "utf-8"));
+  } catch {
+    console.error(pc6.red(`\u274C Error reading vv-manifest.json: Invalid JSON format.`));
+    process.exit(1);
+    return;
+  }
+  const installedComponents = manifest.components || {};
+  const installedSlugs = Object.keys(installedComponents);
+  if (installedSlugs.length === 0) {
+    console.log(pc6.yellow(`
+\u26A0\uFE0F  No components are registered as installed in vv-manifest.json.`));
+    console.log(`\u{1F449} Add components using ${pc6.bold(pc6.cyan("vv add <slug>"))}
+`);
+    return;
+  }
+  if (slug) {
+    try {
+      validateSlug(slug);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(pc6.red(`
+\u274C ${message}
+`));
+      process.exit(1);
+    }
+    if (!installedComponents[slug]) {
+      console.log(pc6.red(`
+\u274C Component "${slug}" is not installed in this project.`));
+      console.log(`\u{1F449} Run ${pc6.cyan(`vv add ${slug}`)} to install it.
+`);
+      return;
+    }
+    const localInfo = installedComponents[slug];
+    const spinner = ora3({
+      text: `Checking updates for ${pc6.cyan(slug)}...`,
+      color: "cyan"
+    }).start();
+    try {
+      const remoteComponent = await fetchComponent(slug);
+      spinner.stop();
+      const localVersion = localInfo.version ?? "unknown";
+      const remoteVersion = remoteComponent.version;
+      console.log(pc6.bold(pc6.cyan(`
+Component Diff: ${slug}`)));
+      console.log(`  \u2022 Local version:  ${pc6.yellow(localVersion)}`);
+      console.log(`  \u2022 Latest version: ${pc6.green(remoteVersion)}`);
+      if (localVersion === remoteVersion) {
+        console.log(`  \u2022 Status:         ${pc6.green("\u2714 Up to date")}
+`);
+      } else {
+        console.log(`  \u2022 Status:         ${pc6.bold(pc6.yellow("\u26A0\uFE0F  Update available!"))}`);
+        console.log(`  \u2022 Run ${pc6.bold(pc6.cyan(`vv add ${slug} --overwrite`))} to update.
+`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      spinner.fail(pc6.red(`Failed to fetch remote component details: ${message}`));
+      process.exit(1);
+    }
+  } else {
+    const spinner = ora3({
+      text: "Comparing local components with registry index...",
+      color: "cyan"
+    }).start();
+    try {
+      const registryIndex = await fetchRegistryIndex();
+      spinner.stop();
+      console.log(pc6.bold(pc6.cyan("\nVector Vesper Component Version Comparison\n")));
+      console.log(pc6.dim("  ----------------------------------------------------------------------"));
+      console.log(
+        `  ${pc6.bold(pc6.white("Component".padEnd(25)))} ${pc6.bold(
+          pc6.white("Local".padEnd(10))
+        )} ${pc6.bold(pc6.white("Latest".padEnd(10)))} ${pc6.bold(pc6.white("Status"))}`
+      );
+      console.log(pc6.dim("  ----------------------------------------------------------------------"));
+      let updatesAvailableCount = 0;
+      for (const instSlug of installedSlugs) {
+        const localInfo = installedComponents[instSlug];
+        const localVersion = localInfo?.version ?? "unknown";
+        const remoteInfo = registryIndex.components.find((c) => c.slug === instSlug);
+        if (!remoteInfo) {
+          console.log(
+            `  ${pc6.cyan(instSlug.padEnd(25))} ${pc6.yellow(
+              localVersion.padEnd(10)
+            )} ${pc6.red("unknown".padEnd(10))} ${pc6.red("Not found in registry")}`
+          );
+        } else {
+          const remoteVersion = remoteInfo.version;
+          if (localVersion === remoteVersion) {
+            console.log(
+              `  ${pc6.cyan(instSlug.padEnd(25))} ${pc6.gray(
+                localVersion.padEnd(10)
+              )} ${pc6.gray(remoteVersion.padEnd(10))} ${pc6.green("\u2714 Up to date")}`
+            );
+          } else {
+            updatesAvailableCount++;
+            console.log(
+              `  ${pc6.cyan(instSlug.padEnd(25))} ${pc6.yellow(
+                localVersion.padEnd(10)
+              )} ${pc6.green(remoteVersion.padEnd(10))} ${pc6.bold(
+                pc6.yellow("\u26A0\uFE0F  Update available")
+              )}`
+            );
+          }
+        }
+      }
+      console.log(pc6.dim("  ----------------------------------------------------------------------"));
+      if (updatesAvailableCount > 0) {
+        console.log(
+          `
+\u{1F4E2} ${pc6.bold(pc6.yellow(String(updatesAvailableCount)))} component(s) have updates available.`
+        );
+        console.log(`\u{1F449} Run ${pc6.bold(pc6.cyan("vv add <slug> --overwrite"))} to update a component.
+`);
+      } else {
+        console.log(`
+${pc6.green("\u2714")} All components are up to date!
+`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      spinner.fail(pc6.red(`Failed to check updates: ${message}`));
+      process.exit(1);
+    }
+  }
+}
+
+// src/commands/auth.ts
+import pc7 from "picocolors";
+async function loginCommand(key) {
+  if (!key || key.trim().length === 0) {
+    logger.error("Please provide a license key.");
+    console.log(`
+  Usage: ${pc7.cyan("vv login <your-license-key>")}`);
+    console.log(`  \u{1F511} Get a key at ${pc7.cyan("https://vectorvesper.dev/pricing")}
+`);
+    process.exit(1);
+  }
+  const trimmedKey = key.trim();
+  if (trimmedKey.length < 8) {
+    logger.error("That doesn't look like a valid license key.");
+    console.log(`
+  \u{1F511} License keys are available at ${pc7.cyan("https://vectorvesper.dev/pricing")}
+`);
+    process.exit(1);
+  }
+  const config = loadGlobalConfig();
+  config.auth = {
+    ...config.auth,
+    token: trimmedKey
+  };
+  try {
+    saveGlobalConfig(config);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to save credentials: ${message}`);
+    process.exit(1);
+  }
+  console.log("");
+  console.log(`  ${pc7.green(pc7.bold("\u2714"))} License key saved successfully!`);
+  console.log(`  ${pc7.dim("Stored at:")} ${pc7.cyan(getGlobalConfigPath())}`);
+  console.log("");
+  console.log(`  ${pc7.dim("Pro components are now available when you run")} ${pc7.cyan("vv add <slug>")}`);
+  console.log(`  ${pc7.dim("To verify your account:")} ${pc7.cyan("vv whoami")}`);
+  console.log("");
+}
+async function logoutCommand() {
+  const config = loadGlobalConfig();
+  if (!config.auth?.token) {
+    console.log(`
+  ${pc7.dim("You're not logged in. Nothing to do.")}
+`);
+    return;
+  }
+  delete config.auth;
+  try {
+    saveGlobalConfig(config);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to clear credentials: ${message}`);
+    process.exit(1);
+  }
+  console.log("");
+  console.log(`  ${pc7.green(pc7.bold("\u2714"))} Logged out successfully.`);
+  console.log(`  ${pc7.dim("Your license key has been removed from")} ${pc7.cyan(getGlobalConfigPath())}`);
+  console.log(`  ${pc7.dim("Free components remain available.")}`);
+  console.log("");
+}
+async function whoamiCommand() {
+  const config = loadGlobalConfig();
+  console.log("");
+  console.log(pc7.bold(pc7.cyan("  Vector Vesper Account Status\n")));
+  if (config.auth?.token) {
+    const maskedKey = config.auth.token.slice(0, 6) + "\u2026" + config.auth.token.slice(-4);
+    const tier = config.auth.tier || "pro";
+    console.log(`  ${pc7.bold("Status:")}   ${pc7.green("Authenticated")}`);
+    console.log(`  ${pc7.bold("Key:")}      ${pc7.cyan(maskedKey)}`);
+    console.log(`  ${pc7.bold("Tier:")}     ${pc7.magenta(tier)}`);
+    if (config.auth.email) {
+      console.log(`  ${pc7.bold("Email:")}    ${pc7.cyan(config.auth.email)}`);
+    }
+    if (config.auth.expiresAt) {
+      const expiry = new Date(config.auth.expiresAt);
+      const now = /* @__PURE__ */ new Date();
+      const isExpired = expiry < now;
+      console.log(`  ${pc7.bold("Expires:")}  ${isExpired ? pc7.red("EXPIRED") : pc7.green(expiry.toLocaleDateString())}`);
+    }
+    console.log("");
+    console.log(`  ${pc7.dim("Config:")} ${pc7.cyan(getGlobalConfigPath())}`);
+    console.log(`  ${pc7.dim("Manage your account at")} ${pc7.cyan("https://vectorvesper.dev/account")}`);
+  } else {
+    console.log(`  ${pc7.bold("Status:")}   ${pc7.yellow("Anonymous (free tier)")}`);
+    console.log(`  ${pc7.bold("Access:")}   ${pc7.dim("Free components only")}`);
+    console.log("");
+    console.log(`  ${pc7.dim("To unlock pro components:")}`);
+    console.log(`  ${pc7.cyan("vv login <your-license-key>")}`);
+    console.log(`  \u{1F511} ${pc7.dim("Get a key at")} ${pc7.cyan("https://vectorvesper.dev/pricing")}`);
+  }
+  console.log("");
+}
+
+// src/index.ts
+var version = true ? "0.1.0" : "0.0.0-dev";
+var program = new Command();
+program.name("vv").description("Vector Vesper CLI \u2014 add visual components to your React project").version(version).option("--verbose", "Show detailed debug output").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.verbose) {
+    setVerbose(true);
+  }
+});
+program.command("init").description("Initialize Vector Vesper configuration in your project").option("-y, --yes", "Accept all default prompts based on project detection").action(async (options) => {
+  await initCommand(options);
+});
+program.command("list").description("List all available components in the registry").action(async () => {
+  await listCommand();
+});
+program.command("add <slug>").description("Add a component to your project").option("-o, --overwrite", "Overwrite existing files without prompting").option("-y, --yes", "Accept all default prompts").option("-d, --dry-run", "Simulate the installation without writing files").action(async (slug, options) => {
+  await addCommand(slug, options);
+});
+program.command("info").description("Show project diagnostics and list installed components").action(async () => {
+  await infoCommand();
+});
+program.command("diff [slug]").description("Check for updates against the component registry").action(async (slug) => {
+  await diffCommand(slug);
+});
+program.command("login <key>").description("Authenticate with a license key for pro components").action(async (key) => {
+  await loginCommand(key);
+});
+program.command("logout").description("Clear stored license credentials").action(async () => {
+  await logoutCommand();
+});
+program.command("whoami").description("Show current authentication status").action(async () => {
+  await whoamiCommand();
+});
+process.on("unhandledRejection", (error) => {
+  console.error("An unexpected error occurred:", error instanceof Error ? error.message : error);
+  process.exit(1);
+});
+await program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "vectorvesper",
+  "version": "0.1.0",
+  "description": "Add premium WebGL and React visual components to your project via CLI",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "bin": {
+    "vv": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vectorvesper/vector-vesper.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://vectorvesper.dev",
+  "bugs": {
+    "url": "https://github.com/vectorvesper/vector-vesper/issues"
+  },
+  "keywords": [
+    "react",
+    "webgl",
+    "three",
+    "threejs",
+    "components",
+    "cli",
+    "ui",
+    "visual",
+    "animation",
+    "gsap",
+    "shader",
+    "interactive"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "commander": "^12.0.0",
+    "ora": "^8.0.1",
+    "picocolors": "^1.0.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.2",
+    "tsup": "^8.0.2",
+    "typescript": "^6.0.3"
+  }
+}