vectorvesper 1.2.0 → 2.0.1

package/dist/index.js

@@ -1,304 +1,33 @@
 #!/usr/bin/env node
+import {
+  detectProject,
+  fetchComponent,
+  fetchRegistryIndex
+} from "./chunk-HOJ3DQSV.js";
+import {
+  getAuthToken,
+  getGlobalConfigPath,
+  loadConfig,
+  loadGlobalConfig,
+  logger,
+  resolveAlias,
+  saveGlobalConfig,
+  setVerbose,
+  validateSlug,
+  writeConfig
+} from "./chunk-SFP5K3ZO.js";
 
 // 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 pc from "picocolors";
 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 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 {
-    }
-  }
-  const allDeps = { ...dependencies, ...devDependencies };
-  const tailwindConfigs = [
-    "tailwind.config.js",
-    "tailwind.config.ts",
-    "tailwind.config.cjs",
-    "tailwind.config.mjs"
-  ];
-  const hasTailwindConfig = tailwindConfigs.some(
-    (config) => fs.existsSync(path.join(rootPath, config))
-  );
-  const hasTailwindDep = "tailwindcss" in allDeps || "@tailwindcss/postcss" in allDeps || "@tailwindcss/vite" in allDeps;
-  const hasTailwind = hasTailwindConfig || hasTailwindDep;
-  let framework = "unknown";
-  let nextRouter;
-  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(),
-  // Optional metadata — kept in sync with the registry builder schema.
-  // Declared here (rather than relying on .passthrough()) so the CLI can
-  // read them with full type-safety for post-install guidance.
-  entry: z.string().optional(),
-  exportName: z.string().optional(),
-  usesTailwind: z.boolean().optional(),
-  fallbacks: z.array(z.string()).optional(),
-  recipes: z.array(z.string()).optional(),
-  docsUrl: z.string().optional(),
-  previewUrl: z.string().optional()
-}).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(),
-  entry: z.string().optional(),
-  exportName: z.string().optional(),
-  usesTailwind: z.boolean().optional()
-}).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 "npx vectorvesper 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 "npx vectorvesper 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  ")));
+  intro(pc.cyan(pc.bold("  Vector Vesper Setup  ")));
   const projectInfo = detectProject();
   let tsx = projectInfo.isTypeScript;
   let framework = projectInfo.framework;
@@ -308,39 +37,39 @@ async function initCommand(options = {}) {
       const existingConfig = loadConfig();
       if (existingConfig) {
         const shouldOverwrite = await confirm({
-          message: pc2.yellow("vv.config.json already exists. Overwrite it?"),
+          message: pc.yellow("vv.config.json already exists. Overwrite it?"),
           initialValue: false
         });
         if (isCancel(shouldOverwrite) || !shouldOverwrite) {
-          outro(pc2.red("Setup cancelled."));
+          outro(pc.red("Setup cancelled."));
           return;
         }
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.log(pc2.yellow(`
+      console.log(pc.yellow(`
   \u26A0\uFE0F  ${message}
 `));
       const shouldReplace = await confirm({
-        message: pc2.yellow("Replace the corrupted config?"),
+        message: pc.yellow("Replace the corrupted config?"),
         initialValue: true
       });
       if (isCancel(shouldReplace) || !shouldReplace) {
-        outro(pc2.red("Setup cancelled."));
+        outro(pc.red("Setup cancelled."));
         return;
       }
     }
     const tsxResponse = await confirm({
-      message: `Use TypeScript? ${pc2.dim(`(Detected: ${projectInfo.isTypeScript ? "Yes" : "No"})`)}`,
+      message: `Use TypeScript? ${pc.dim(`(Detected: ${projectInfo.isTypeScript ? "Yes" : "No"})`)}`,
       initialValue: projectInfo.isTypeScript
     });
     if (isCancel(tsxResponse)) {
-      outro(pc2.red("Setup cancelled."));
+      outro(pc.red("Setup cancelled."));
       return;
     }
     tsx = tsxResponse;
     const frameworkResponse = await select({
-      message: `Configure your framework: ${pc2.dim(`(Detected: ${projectInfo.framework})`)}`,
+      message: `Configure your framework: ${pc.dim(`(Detected: ${projectInfo.framework})`)}`,
       options: [
         { value: "next", label: "Next.js" },
         { value: "vite", label: "Vite" },
@@ -349,7 +78,7 @@ async function initCommand(options = {}) {
       initialValue: projectInfo.framework
     });
     if (isCancel(frameworkResponse)) {
-      outro(pc2.red("Setup cancelled."));
+      outro(pc.red("Setup cancelled."));
       return;
     }
     framework = frameworkResponse;
@@ -365,15 +94,15 @@ async function initCommand(options = {}) {
       }
     });
     if (isCancel(aliasResponse)) {
-      outro(pc2.red("Setup cancelled."));
+      outro(pc.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}`));
+    console.log(pc.dim(`  \u26A1 Running in non-interactive mode (-y)`));
+    console.log(pc.dim(`  \u2022 TypeScript: ${tsx ? "Yes" : "No"}`));
+    console.log(pc.dim(`  \u2022 Framework: ${framework}`));
+    console.log(pc.dim(`  \u2022 Components Alias: ${aliasInput}`));
   }
   const config = {
     tsx,
@@ -385,190 +114,34 @@ async function initCommand(options = {}) {
   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 absoluteTargetDir = path.join(process.cwd(), targetLocalDir);
+    if (!fs.existsSync(absoluteTargetDir)) {
+      fs.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");
+    const manifestPath = path.join(process.cwd(), "vv-manifest.json");
+    if (!fs.existsSync(manifestPath)) {
+      fs.writeFileSync(manifestPath, JSON.stringify({ components: {} }, null, 2), "utf-8");
     }
     console.log("");
     outro(
-      `${pc2.green(pc2.bold("\u2714 Success!"))} Vector Vesper initialized.
+      `${pc.green(pc.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")}
+  \u2022 Configuration written to ${pc.cyan("vv.config.json")}
+  \u2022 Target directory created at ${pc.cyan(targetLocalDir)}
+  \u2022 Manifest created at ${pc.cyan("vv-manifest.json")}
 
-  \u{1F449} Next, run: ${pc2.bold(pc2.cyan("npx vectorvesper add <slug>"))} to add a component.`
+  \u{1F449} Next, run: ${pc.bold(pc.cyan("npx vectorvesper add <slug>"))} to add a component.`
     );
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    outro(pc2.red(`Failed to initialize: ${message}`));
+    outro(pc.red(`Failed to initialize: ${message}`));
     process.exit(1);
   }
 }
 
 // src/commands/list.ts
-import pc3 from "picocolors";
+import pc2 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 "npx vectorvesper 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 a license.
-\u{1F449} Get lifetime access at https://vectorvesper.dev/pricing
-\u{1F4A1} Run "npx vectorvesper list" to see all free components.`
-      );
-    case 403:
-      throw new Error(
-        `Access denied. Your license doesn't include this component.
-\u{1F449} Check your account at https://vectorvesper.dev/account
-\u{1F4A1} Run "npx vectorvesper whoami" to see your current access.`
-      );
-    case 404:
-      throw new Error(
-        `Component not found in the registry.
-\u{1F449} Run "npx vectorvesper 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"
-  };
-  const isPublicRegistry = url.includes("raw.githubusercontent.com");
-  if (token && !isPublicRegistry) {
-    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...",
@@ -576,55 +149,55 @@ async function listCommand() {
   }).start();
   try {
     const registry = await fetchRegistryIndex();
-    spinner.succeed(pc3.green("Fetched components list successfully!\n"));
+    spinner.succeed(pc2.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"));
+      console.log(pc2.dim("  No components available in the registry yet."));
+      console.log(pc2.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("--------------------------------------------------------------------------------"));
+    console.log(pc2.bold(pc2.white("Vector Vesper Available Components:")));
+    console.log(pc2.dim("--------------------------------------------------------------------------------"));
     for (const c of registry.components) {
-      const slugCol = pc3.cyan(c.slug.padEnd(25));
-      const categoryCol = pc3.yellow(c.category.padEnd(15));
+      const slugCol = pc2.cyan(c.slug.padEnd(25));
+      const categoryCol = pc2.yellow(c.category.padEnd(15));
       let tierBadge;
       if (c.tier === "pro") {
-        tierBadge = hasAuth ? pc3.magenta("pro ") : pc3.dim("\u{1F512}  ");
+        tierBadge = hasAuth ? pc2.magenta("pro ") : pc2.dim("\u{1F512}  ");
       } else {
-        tierBadge = pc3.green("free");
+        tierBadge = pc2.green("free");
       }
-      console.log(`${slugCol} [${tierBadge}]  ${categoryCol}  ${pc3.gray(c.description)}`);
+      console.log(`${slugCol} [${tierBadge}]  ${categoryCol}  ${pc2.gray(c.description)}`);
     }
-    console.log(pc3.dim("--------------------------------------------------------------------------------"));
+    console.log(pc2.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` : ""}`);
+  ${pc2.green(String(freeCount))} free components${proCount > 0 ? ` \xB7 ${pc2.magenta(String(proCount))} pro components` : ""}`);
     if (proCount > 0 && !hasAuth) {
-      console.log(`  \u{1F511} ${pc3.dim("Unlock pro components:")} ${pc3.cyan("npx vectorvesper login <key>")} ${pc3.dim("\xB7")} ${pc3.cyan("https://vectorvesper.dev/pricing")}`);
+      console.log(`  \u{1F511} ${pc2.dim("Unlock pro components:")} ${pc2.cyan("npx vectorvesper login <key>")} ${pc2.dim("\xB7")} ${pc2.cyan("https://vectorvesper.dev/pricing")}`);
     }
     console.log(`
-\u{1F449} Run ${pc3.bold(pc3.cyan("npx vectorvesper add <slug>"))} to add a component to your project.
+\u{1F449} Run ${pc2.bold(pc2.cyan("npx vectorvesper 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}`));
+    spinner.fail(pc2.red(`Failed to fetch components list: ${message}`));
     process.exit(1);
   }
 }
 
 // src/commands/add.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import ora2 from "ora";
-import pc6 from "picocolors";
+import pc5 from "picocolors";
 import { confirm as confirm2, isCancel as isCancel2 } from "@clack/prompts";
 
 // src/utils/installer.ts
-import fs5 from "fs";
-import path5 from "path";
-import pc4 from "picocolors";
+import fs2 from "fs";
+import path2 from "path";
+import pc3 from "picocolors";
 var MAX_DEPTH = 20;
 function toForwardSlash(p) {
   return p.replace(/\\/g, "/");
@@ -644,8 +217,8 @@ async function resolveComponentTree(slug) {
     if (component.tier === "pro" && !getAuthToken()) {
       throw new Error(
         `"${componentSlug}" is a Pro component and requires a license.
-\u{1F449} Run ${pc4.cyan("npx vectorvesper login <your-license-key>")} to unlock pro components.
-\u{1F511} Get a license at ${pc4.cyan("https://vectorvesper.dev/pricing")}`
+\u{1F449} Run ${pc3.cyan("npx vectorvesper login <your-license-key>")} to unlock pro components.
+\u{1F511} Get a license at ${pc3.cyan("https://vectorvesper.dev/pricing")}`
       );
     }
     for (const depSlug of component.registryDependencies ?? []) {
@@ -658,12 +231,12 @@ async function resolveComponentTree(slug) {
 }
 function planFiles(components, installDir, projectRoot) {
   const planned = [];
-  const compDir = path5.join(projectRoot, installDir);
+  const compDir = path2.join(projectRoot, installDir);
   for (const component of components) {
     for (const file of component.files) {
-      const absolutePath = path5.resolve(compDir, file.target);
-      const relativeFromRoot = path5.relative(projectRoot, absolutePath);
-      if (relativeFromRoot.startsWith("..") || path5.isAbsolute(relativeFromRoot)) {
+      const absolutePath = path2.resolve(compDir, file.target);
+      const relativeFromRoot = path2.relative(projectRoot, absolutePath);
+      if (relativeFromRoot.startsWith("..") || path2.isAbsolute(relativeFromRoot)) {
         throw new Error(
           `Security Error: component target tries to escape project root: ${file.target}`
         );
@@ -673,7 +246,7 @@ function planFiles(components, installDir, projectRoot) {
         relativePath: relativeFromRoot,
         target: file.target,
         content: file.content,
-        exists: fs5.existsSync(absolutePath)
+        exists: fs2.existsSync(absolutePath)
       });
     }
   }
@@ -681,28 +254,28 @@ function planFiles(components, installDir, projectRoot) {
 }
 function writeFiles(files) {
   for (const file of files) {
-    const folder = path5.dirname(file.absolutePath);
-    if (!fs5.existsSync(folder)) {
-      fs5.mkdirSync(folder, { recursive: true });
+    const folder = path2.dirname(file.absolutePath);
+    if (!fs2.existsSync(folder)) {
+      fs2.mkdirSync(folder, { recursive: true });
     }
-    fs5.writeFileSync(file.absolutePath, file.content, "utf-8");
+    fs2.writeFileSync(file.absolutePath, file.content, "utf-8");
   }
 }
 var MANIFEST_NAME = "vv-manifest.json";
 function getManifestPath(projectRoot) {
-  return path5.join(projectRoot, MANIFEST_NAME);
+  return path2.join(projectRoot, MANIFEST_NAME);
 }
 function readManifest(projectRoot) {
   const manifestPath = getManifestPath(projectRoot);
-  if (!fs5.existsSync(manifestPath)) {
+  if (!fs2.existsSync(manifestPath)) {
     return { components: {} };
   }
-  const parsed = JSON.parse(fs5.readFileSync(manifestPath, "utf-8"));
+  const parsed = JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
   if (!parsed.components) parsed.components = {};
   return parsed;
 }
 function writeManifest(projectRoot, manifest) {
-  fs5.writeFileSync(getManifestPath(projectRoot), JSON.stringify(manifest, null, 2), "utf-8");
+  fs2.writeFileSync(getManifestPath(projectRoot), JSON.stringify(manifest, null, 2), "utf-8");
 }
 function recordInstall(components, installDir, projectRoot) {
   const manifest = readManifest(projectRoot);
@@ -710,7 +283,7 @@ function recordInstall(components, installDir, projectRoot) {
   for (const component of components) {
     manifest.components[component.slug] = {
       version: component.version,
-      installedAt: toForwardSlash(path5.join(installDir, component.slug)),
+      installedAt: toForwardSlash(path2.join(installDir, component.slug)),
       installedOn: today,
       files: component.files.map((f) => f.target)
     };
@@ -718,7 +291,7 @@ function recordInstall(components, installDir, projectRoot) {
   writeManifest(projectRoot, manifest);
 }
 function findOrphanedFiles(components, installDir, projectRoot, previousManifest) {
-  const compDir = path5.join(projectRoot, installDir);
+  const compDir = path2.join(projectRoot, installDir);
   const currentTargets = /* @__PURE__ */ new Set();
   for (const component of components) {
     for (const file of component.files) currentTargets.add(file.target);
@@ -732,10 +305,10 @@ function findOrphanedFiles(components, installDir, projectRoot, previousManifest
       if (currentTargets.has(target)) continue;
       if (seen.has(target)) continue;
       seen.add(target);
-      const absolutePath = path5.resolve(compDir, target);
-      const relativeFromRoot = path5.relative(projectRoot, absolutePath);
-      if (relativeFromRoot.startsWith("..") || path5.isAbsolute(relativeFromRoot)) continue;
-      if (!fs5.existsSync(absolutePath)) continue;
+      const absolutePath = path2.resolve(compDir, target);
+      const relativeFromRoot = path2.relative(projectRoot, absolutePath);
+      if (relativeFromRoot.startsWith("..") || path2.isAbsolute(relativeFromRoot)) continue;
+      if (!fs2.existsSync(absolutePath)) continue;
       orphans.push({ absolutePath, relativePath: relativeFromRoot, target });
     }
   }
@@ -743,26 +316,26 @@ function findOrphanedFiles(components, installDir, projectRoot, previousManifest
 }
 function removeFiles(files) {
   for (const file of files) {
-    if (fs5.existsSync(file.absolutePath)) {
-      fs5.rmSync(file.absolutePath, { force: true });
+    if (fs2.existsSync(file.absolutePath)) {
+      fs2.rmSync(file.absolutePath, { force: true });
     }
   }
 }
 
 // src/utils/install.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import { spawnSync } from "child_process";
 var NPM_NAME_REGEX = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
 function isValidPackageName(name) {
   return NPM_NAME_REGEX.test(name);
 }
 function getMissingDependencies(components, projectRoot) {
-  const pkgPath = path6.join(projectRoot, "package.json");
-  if (!fs6.existsSync(pkgPath)) return [];
+  const pkgPath = path3.join(projectRoot, "package.json");
+  if (!fs3.existsSync(pkgPath)) return [];
   let installed = {};
   try {
-    const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
     installed = {
       ...pkg.dependencies,
       ...pkg.devDependencies,
@@ -807,7 +380,7 @@ function installDependencies(deps, pm, projectRoot) {
 }
 
 // src/utils/guidance.ts
-import pc5 from "picocolors";
+import pc4 from "picocolors";
 function toPascalCase(input) {
   return input.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
@@ -858,24 +431,24 @@ const ${varName} = dynamic(
 }
 function printGuidance(component, ctx) {
   const g = buildGuidance(component, ctx);
-  console.log(pc5.bold(pc5.white(`
+  console.log(pc4.bold(pc4.white(`
 Using ${component.title || component.name}:`)));
   if (g.ssrSnippet) {
-    console.log(pc5.dim("  // SSR-safe (Next.js) \u2014 disables server rendering for WebGL:"));
+    console.log(pc4.dim("  // SSR-safe (Next.js) \u2014 disables server rendering for WebGL:"));
     for (const line of g.ssrSnippet.split("\n")) {
-      console.log(line ? `  ${pc5.cyan(line)}` : "");
+      console.log(line ? `  ${pc4.cyan(line)}` : "");
     }
   } else {
-    console.log(`  ${pc5.cyan(g.importSnippet)}`);
+    console.log(`  ${pc4.cyan(g.importSnippet)}`);
   }
   for (const note of g.notes) {
-    console.log(`  ${pc5.green("\u2022")} ${pc5.dim(note)}`);
+    console.log(`  ${pc4.green("\u2022")} ${pc4.dim(note)}`);
   }
   for (const warning of g.warnings) {
-    console.log(`  ${pc5.yellow("\u26A0")}  ${pc5.yellow(warning)}`);
+    console.log(`  ${pc4.yellow("\u26A0")}  ${pc4.yellow(warning)}`);
   }
   if (g.docsUrl) {
-    console.log(`  ${pc5.dim("Docs:")} ${pc5.cyan(g.docsUrl)}`);
+    console.log(`  ${pc4.dim("Docs:")} ${pc4.cyan(g.docsUrl)}`);
   }
 }
 
@@ -943,11 +516,11 @@ async function handleDependencies(components, projectRoot, projectInfo, options)
   const missing = getMissingDependencies(components, projectRoot);
   if (missing.length === 0) return;
   const installCmd = getInstallCommand(projectInfo.packageManager, missing);
-  const depsLabel = missing.map((d) => pc6.cyan(d)).join(", ");
+  const depsLabel = missing.map((d) => pc5.cyan(d)).join(", ");
   if (options.install === false) {
-    console.log(pc6.yellow(`
+    console.log(pc5.yellow(`
 \u26A0\uFE0F  Missing dependencies: ${depsLabel}`));
-    console.log(`  Run: ${pc6.bold(pc6.cyan(installCmd))}`);
+    console.log(`  Run: ${pc5.bold(pc5.cyan(installCmd))}`);
     return;
   }
   let shouldInstall = options.yes === true;
@@ -958,44 +531,44 @@ async function handleDependencies(components, projectRoot, projectInfo, options)
       initialValue: true
     });
     if (isCancel2(answer)) {
-      console.log(pc6.dim(`  Skipped. Run: ${pc6.cyan(installCmd)}`));
+      console.log(pc5.dim(`  Skipped. Run: ${pc5.cyan(installCmd)}`));
       return;
     }
     shouldInstall = answer;
   }
   if (!shouldInstall) {
-    console.log(pc6.dim(`  Skipped. Run: ${pc6.cyan(installCmd)} when ready.`));
+    console.log(pc5.dim(`  Skipped. Run: ${pc5.cyan(installCmd)} when ready.`));
     return;
   }
-  console.log(pc6.dim(`
+  console.log(pc5.dim(`
 Installing dependencies with ${projectInfo.packageManager}...`));
   try {
     const ok = installDependencies(missing, projectInfo.packageManager, projectRoot);
     if (ok) {
-      console.log(pc6.green(`\u2714 Dependencies installed.`));
+      console.log(pc5.green(`\u2714 Dependencies installed.`));
     } else {
-      console.log(pc6.yellow(`\u26A0\uFE0F  Dependency install did not complete. Run manually: ${pc6.cyan(installCmd)}`));
+      console.log(pc5.yellow(`\u26A0\uFE0F  Dependency install did not complete. Run manually: ${pc5.cyan(installCmd)}`));
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.log(pc6.yellow(`\u26A0\uFE0F  ${message}`));
-    console.log(`  Run manually: ${pc6.bold(pc6.cyan(installCmd))}`);
+    console.log(pc5.yellow(`\u26A0\uFE0F  ${message}`));
+    console.log(`  Run manually: ${pc5.bold(pc5.cyan(installCmd))}`);
   }
 }
 async function handlePrune(orphans, slug, options) {
   if (orphans.length === 0) return;
-  const list = orphans.map((o) => `    ${pc6.dim("\u2022")} ${pc6.cyan(o.relativePath)}`).join("\n");
+  const list = orphans.map((o) => `    ${pc5.dim("\u2022")} ${pc5.cyan(o.relativePath)}`).join("\n");
   let shouldPrune = options.prune === true;
   if (!shouldPrune) {
     console.log(
-      pc6.yellow(
+      pc5.yellow(
         `
-\u{1F9F9} ${orphans.length} file(s) from a previous version of ${pc6.cyan(slug)} are no longer part of it:`
+\u{1F9F9} ${orphans.length} file(s) from a previous version of ${pc5.cyan(slug)} are no longer part of it:`
       )
     );
     console.log(list);
     if (options.yes) {
-      console.log(pc6.dim(`  Re-run with ${pc6.cyan("--prune")} to remove them.`));
+      console.log(pc5.dim(`  Re-run with ${pc5.cyan("--prune")} to remove them.`));
       return;
     }
     const answer = await confirm2({
@@ -1003,16 +576,16 @@ async function handlePrune(orphans, slug, options) {
       initialValue: true
     });
     if (isCancel2(answer) || !answer) {
-      console.log(pc6.dim(`  Left in place. Run with ${pc6.cyan("--prune")} later to remove them.`));
+      console.log(pc5.dim(`  Left in place. Run with ${pc5.cyan("--prune")} later to remove them.`));
       return;
     }
     shouldPrune = true;
   }
   removeFiles(orphans);
-  console.log(pc6.green(`
+  console.log(pc5.green(`
 \u{1F9F9} Removed ${orphans.length} orphaned file(s):`));
   for (const o of orphans) {
-    console.log(`  ${pc6.red("\u2212")} ${pc6.cyan(o.relativePath)}`);
+    console.log(`  ${pc5.red("\u2212")} ${pc5.cyan(o.relativePath)}`);
   }
 }
 async function addCommand(slug, options = {}) {
@@ -1020,7 +593,7 @@ async function addCommand(slug, options = {}) {
     validateSlug(slug);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`${pc6.red(pc6.bold("Error:"))} ${message}`);
+    console.error(`${pc5.red(pc5.bold("Error:"))} ${message}`);
     process.exit(1);
   }
   let config;
@@ -1028,13 +601,13 @@ async function addCommand(slug, options = {}) {
     config = loadConfig();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`${pc6.red(pc6.bold("Error:"))} ${message}`);
+    console.error(`${pc5.red(pc5.bold("Error:"))} ${message}`);
     process.exit(1);
   }
   if (!config) {
     console.error(
-      `${pc6.red(pc6.bold("Error:"))} No ${pc6.cyan("vv.config.json")} found in this directory.
-\u{1F449} Run ${pc6.bold(pc6.cyan("npx vectorvesper init"))} first to set up your project.`
+      `${pc5.red(pc5.bold("Error:"))} No ${pc5.cyan("vv.config.json")} found in this directory.
+\u{1F449} Run ${pc5.bold(pc5.cyan("npx vectorvesper init"))} first to set up your project.`
     );
     process.exit(1);
     return;
@@ -1042,13 +615,13 @@ async function addCommand(slug, options = {}) {
   const projectInfo = detectProject();
   const componentInstallDir = resolveAlias(config.aliases.vv, projectInfo.hasSrcDir);
   const projectRoot = process.cwd();
-  const spinner = ora2({ text: `Resolving component ${pc6.cyan(slug)}...`, color: "cyan" }).start();
+  const spinner = ora2({ text: `Resolving component ${pc5.cyan(slug)}...`, color: "cyan" }).start();
   let resolvedComponents;
   try {
     resolvedComponents = await resolveComponentTree(slug);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    spinner.fail(pc6.red(`Failed to resolve component "${slug}": ${message}`));
+    spinner.fail(pc5.red(`Failed to resolve component "${slug}": ${message}`));
     process.exit(1);
     return;
   }
@@ -1070,7 +643,7 @@ async function addCommand(slug, options = {}) {
     planned = planFiles(resolvedComponents, componentInstallDir, projectRoot);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    spinner.fail(pc6.red(message));
+    spinner.fail(pc5.red(message));
     process.exit(1);
     return;
   }
@@ -1079,11 +652,11 @@ async function addCommand(slug, options = {}) {
     if (file.exists && !options.dryRun && !options.overwrite && !options.yes) {
       spinner.stop();
       const answer = await confirm2({
-        message: pc6.yellow(`File already exists: "${file.relativePath}". Overwrite?`),
+        message: pc5.yellow(`File already exists: "${file.relativePath}". Overwrite?`),
         initialValue: false
       });
       if (isCancel2(answer) || !answer) {
-        console.log(pc6.dim(`  Skipping existing file: ${file.relativePath}`));
+        console.log(pc5.dim(`  Skipping existing file: ${file.relativePath}`));
         spinner.start("Continuing installation...");
         continue;
       }
@@ -1096,7 +669,7 @@ async function addCommand(slug, options = {}) {
     });
   }
   const targetComponent = resolvedComponents[resolvedComponents.length - 1];
-  const installPath = toForwardSlash(path7.join(componentInstallDir, targetComponent.slug));
+  const installPath = toForwardSlash(path4.join(componentInstallDir, targetComponent.slug));
   let orphans = [];
   try {
     const previousManifest = readManifest(projectRoot);
@@ -1105,32 +678,32 @@ async function addCommand(slug, options = {}) {
     orphans = [];
   }
   if (options.dryRun) {
-    spinner.succeed(pc6.yellow("Dry-run: simulation completed. No files were written."));
-    console.log(pc6.bold(pc6.yellow("\n[Dry Run] Files that would be created/modified:")));
+    spinner.succeed(pc5.yellow("Dry-run: simulation completed. No files were written."));
+    console.log(pc5.bold(pc5.yellow("\n[Dry Run] Files that would be created/modified:")));
     for (const file of filesToWrite) {
-      const status = fs7.existsSync(file.absolutePath) ? pc6.yellow("(exists, would overwrite)") : pc6.green("(new)");
-      console.log(`  ${pc6.cyan(file.relativePath)} ${status}`);
+      const status = fs4.existsSync(file.absolutePath) ? pc5.yellow("(exists, would overwrite)") : pc5.green("(new)");
+      console.log(`  ${pc5.cyan(file.relativePath)} ${status}`);
     }
     if (orphans.length > 0) {
-      console.log(pc6.bold(pc6.yellow("\n[Dry Run] Orphaned files from a previous version:")));
+      console.log(pc5.bold(pc5.yellow("\n[Dry Run] Orphaned files from a previous version:")));
       for (const o of orphans) {
-        const note = options.prune ? pc6.red("(would remove)") : pc6.dim("(use --prune to remove)");
-        console.log(`  ${pc6.cyan(o.relativePath)} ${note}`);
+        const note = options.prune ? pc5.red("(would remove)") : pc5.dim("(use --prune to remove)");
+        console.log(`  ${pc5.cyan(o.relativePath)} ${note}`);
       }
     }
     const missing = getMissingDependencies(resolvedComponents, projectRoot);
     if (missing.length > 0) {
-      console.log(pc6.yellow(`
-\u26A0\uFE0F  Would need dependencies: ${missing.map((d) => pc6.cyan(d)).join(", ")}`));
-      console.log(`  ${pc6.dim(getInstallCommand(projectInfo.packageManager, missing))}`);
+      console.log(pc5.yellow(`
+\u26A0\uFE0F  Would need dependencies: ${missing.map((d) => pc5.cyan(d)).join(", ")}`));
+      console.log(`  ${pc5.dim(getInstallCommand(projectInfo.packageManager, missing))}`);
     }
     console.log("");
-    console.log(pc6.bold(pc6.yellow(`\u2714 [Dry Run] Would add ${pc6.cyan(targetComponent.slug)} to ${installPath}`)));
+    console.log(pc5.bold(pc5.yellow(`\u2714 [Dry Run] Would add ${pc5.cyan(targetComponent.slug)} to ${installPath}`)));
     console.log("");
     return;
   }
   if (filesToWrite.length === 0) {
-    spinner.succeed(pc6.green("All files skipped (already up to date)."));
+    spinner.succeed(pc5.green("All files skipped (already up to date)."));
     await handlePrune(orphans, targetComponent.slug, options);
     return;
   }
@@ -1139,7 +712,7 @@ async function addCommand(slug, options = {}) {
     writeFiles(filesToWrite);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    spinner.fail(pc6.red(`Failed to write files: ${message}`));
+    spinner.fail(pc5.red(`Failed to write files: ${message}`));
     process.exit(1);
     return;
   }
@@ -1150,10 +723,10 @@ async function addCommand(slug, options = {}) {
     logger.warn(`Failed to update vv-manifest.json: ${message}`);
     logger.warn("Component was installed but may not appear in 'npx vectorvesper info' or 'npx vectorvesper diff'.");
   }
-  spinner.succeed(pc6.green("Files written successfully!"));
-  console.log(pc6.dim("\nCreated files:"));
+  spinner.succeed(pc5.green("Files written successfully!"));
+  console.log(pc5.dim("\nCreated files:"));
   for (const file of filesToWrite) {
-    console.log(`  ${pc6.green("\u2714")} ${pc6.cyan(file.relativePath)}`);
+    console.log(`  ${pc5.green("\u2714")} ${pc5.cyan(file.relativePath)}`);
   }
   await handlePrune(orphans, targetComponent.slug, options);
   await handleDependencies(resolvedComponents, projectRoot, projectInfo, options);
@@ -1163,20 +736,20 @@ async function addCommand(slug, options = {}) {
     hasTailwind: projectInfo.hasTailwind
   });
   if (transpileWarnings.length > 0) {
-    console.log(pc6.yellow(`
+    console.log(pc5.yellow(`
   \u26A0\uFE0F  Some files were kept as TypeScript:`));
-    for (const w of transpileWarnings) console.log(`    ${pc6.dim(w)}`);
+    for (const w of transpileWarnings) console.log(`    ${pc5.dim(w)}`);
   }
   console.log("");
-  console.log(pc6.bold(pc6.green(`\u2714 Added ${pc6.cyan(targetComponent.slug)} to ${installPath}`)));
+  console.log(pc5.bold(pc5.green(`\u2714 Added ${pc5.cyan(targetComponent.slug)} to ${installPath}`)));
   console.log("");
-  console.log(pc6.gray("\u{1F449} Loving Vector Vesper? Star the repo: https://github.com/vectorvesper/vv-components"));
-  console.log(pc6.gray("\u{1F680} Premium shader & pixel systems: https://vectorvesper.dev/pricing"));
+  console.log(pc5.gray("\u{1F449} Loving Vector Vesper? Star the repo: https://github.com/vectorvesper/vv-components"));
+  console.log(pc5.gray("\u{1F680} Premium shader & pixel systems: https://vectorvesper.dev/pricing"));
   console.log("");
 }
 
 // src/commands/update.ts
-import pc7 from "picocolors";
+import pc6 from "picocolors";
 import ora3 from "ora";
 async function updateCommand(slug, options = {}) {
   const projectRoot = process.cwd();
@@ -1185,14 +758,14 @@ async function updateCommand(slug, options = {}) {
     config = loadConfig();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`${pc7.red(pc7.bold("Error:"))} ${message}`);
+    console.error(`${pc6.red(pc6.bold("Error:"))} ${message}`);
     process.exit(1);
     return;
   }
   if (!config) {
     console.error(
-      `${pc7.red(pc7.bold("Error:"))} No ${pc7.cyan("vv.config.json")} found.
-\u{1F449} Run ${pc7.bold(pc7.cyan("npx vectorvesper init"))} first.`
+      `${pc6.red(pc6.bold("Error:"))} No ${pc6.cyan("vv.config.json")} found.
+\u{1F449} Run ${pc6.bold(pc6.cyan("npx vectorvesper init"))} first.`
     );
     process.exit(1);
     return;
@@ -1202,9 +775,9 @@ async function updateCommand(slug, options = {}) {
   const manifest = readManifest(projectRoot);
   const installedSlugs = Object.keys(manifest.components);
   if (installedSlugs.length === 0) {
-    console.log(pc7.yellow(`
+    console.log(pc6.yellow(`
 \u26A0\uFE0F  No components are installed in this project.`));
-    console.log(`\u{1F449} Add one with ${pc7.bold(pc7.cyan("npx vectorvesper add <slug>"))}
+    console.log(`\u{1F449} Add one with ${pc6.bold(pc6.cyan("npx vectorvesper add <slug>"))}
 `);
     return;
   }
@@ -1214,16 +787,16 @@ async function updateCommand(slug, options = {}) {
       validateSlug(slug);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.error(pc7.red(`
+      console.error(pc6.red(`
 \u274C ${message}
 `));
       process.exit(1);
       return;
     }
     if (!manifest.components[slug]) {
-      console.log(pc7.red(`
+      console.log(pc6.red(`
 \u274C Component "${slug}" is not installed in this project.`));
-      console.log(`\u{1F449} Run ${pc7.cyan(`npx vectorvesper add ${slug}`)} to install it.
+      console.log(`\u{1F449} Run ${pc6.cyan(`npx vectorvesper add ${slug}`)} to install it.
 `);
       return;
     }
@@ -1238,7 +811,7 @@ async function updateCommand(slug, options = {}) {
   const updatedComponents = [];
   const transpileWarnings = [];
   for (const target of targets) {
-    spinner.text = `Updating ${pc7.cyan(target)}...`;
+    spinner.text = `Updating ${pc6.cyan(target)}...`;
     try {
       let components = await resolveComponentTree(target);
       const remote = components[components.length - 1];
@@ -1268,26 +841,26 @@ async function updateCommand(slug, options = {}) {
     }
   }
   spinner.stop();
-  console.log(pc7.bold(pc7.cyan("\nVector Vesper Update\n")));
+  console.log(pc6.bold(pc6.cyan("\nVector Vesper Update\n")));
   if (updated.length > 0) {
-    console.log(pc7.bold(pc7.green(`  Updated (${updated.length}):`)));
-    for (const u of updated) console.log(`    ${pc7.green("\u2714")} ${u}`);
-    console.log(pc7.dim("    Note: updating overwrites local edits to these files."));
+    console.log(pc6.bold(pc6.green(`  Updated (${updated.length}):`)));
+    for (const u of updated) console.log(`    ${pc6.green("\u2714")} ${u}`);
+    console.log(pc6.dim("    Note: updating overwrites local edits to these files."));
   }
   if (upToDate.length > 0) {
-    console.log(pc7.bold(pc7.gray(`
+    console.log(pc6.bold(pc6.gray(`
   Already up to date (${upToDate.length}):`)));
-    console.log(`    ${pc7.dim(upToDate.join(", "))}`);
+    console.log(`    ${pc6.dim(upToDate.join(", "))}`);
   }
   if (failed.length > 0) {
-    console.log(pc7.bold(pc7.red(`
+    console.log(pc6.bold(pc6.red(`
   Failed (${failed.length}):`)));
-    for (const f of failed) console.log(`    ${pc7.red("\u2716")} ${f.slug}: ${pc7.dim(f.reason)}`);
+    for (const f of failed) console.log(`    ${pc6.red("\u2716")} ${f.slug}: ${pc6.dim(f.reason)}`);
   }
   if (transpileWarnings.length > 0) {
-    console.log(pc7.yellow(`
+    console.log(pc6.yellow(`
   \u26A0\uFE0F  Some files were kept as TypeScript:`));
-    for (const w of transpileWarnings) console.log(`    ${pc7.dim(w)}`);
+    for (const w of transpileWarnings) console.log(`    ${pc6.dim(w)}`);
   }
   console.log("");
   if (updatedComponents.length > 0) {
@@ -1297,16 +870,16 @@ async function updateCommand(slug, options = {}) {
 }
 
 // src/commands/remove.ts
-import fs8 from "fs";
-import path8 from "path";
-import pc8 from "picocolors";
+import fs5 from "fs";
+import path5 from "path";
+import pc7 from "picocolors";
 import { confirm as confirm3, isCancel as isCancel3 } from "@clack/prompts";
 async function removeCommand(slug, options = {}) {
   try {
     validateSlug(slug);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`${pc8.red(pc8.bold("Error:"))} ${message}`);
+    console.error(`${pc7.red(pc7.bold("Error:"))} ${message}`);
     process.exit(1);
     return;
   }
@@ -1316,14 +889,14 @@ async function removeCommand(slug, options = {}) {
     config = loadConfig();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`${pc8.red(pc8.bold("Error:"))} ${message}`);
+    console.error(`${pc7.red(pc7.bold("Error:"))} ${message}`);
     process.exit(1);
     return;
   }
   if (!config) {
     console.error(
-      `${pc8.red(pc8.bold("Error:"))} No ${pc8.cyan("vv.config.json")} found.
-\u{1F449} Run ${pc8.bold(pc8.cyan("npx vectorvesper init"))} first.`
+      `${pc7.red(pc7.bold("Error:"))} No ${pc7.cyan("vv.config.json")} found.
+\u{1F449} Run ${pc7.bold(pc7.cyan("npx vectorvesper init"))} first.`
     );
     process.exit(1);
     return;
@@ -1331,50 +904,50 @@ async function removeCommand(slug, options = {}) {
   const manifest = readManifest(projectRoot);
   const entry = manifest.components[slug];
   if (!entry) {
-    console.log(pc8.yellow(`
+    console.log(pc7.yellow(`
 \u26A0\uFE0F  Component "${slug}" is not installed (not in vv-manifest.json).`));
-    console.log(`\u{1F449} See installed components with ${pc8.bold(pc8.cyan("npx vectorvesper info"))}
+    console.log(`\u{1F449} See installed components with ${pc7.bold(pc7.cyan("npx vectorvesper info"))}
 `);
     return;
   }
   const projectInfo = detectProject();
   const installDir = resolveAlias(config.aliases.vv, projectInfo.hasSrcDir);
-  const baseDir = path8.join(projectRoot, installDir);
+  const baseDir = path5.join(projectRoot, installDir);
   const targets = entry.files ?? [];
-  const absoluteFiles = targets.map((t) => path8.resolve(baseDir, t));
-  console.log(pc8.bold(pc8.cyan(`
+  const absoluteFiles = targets.map((t) => path5.resolve(baseDir, t));
+  console.log(pc7.bold(pc7.cyan(`
 Remove ${slug}
 `)));
-  console.log(pc8.dim("  The following files will be deleted:"));
+  console.log(pc7.dim("  The following files will be deleted:"));
   for (const f of absoluteFiles) {
-    console.log(`    ${fs8.existsSync(f) ? pc8.red("\u2212") : pc8.dim("\xB7")} ${pc8.cyan(path8.relative(projectRoot, f))}`);
+    console.log(`    ${fs5.existsSync(f) ? pc7.red("\u2212") : pc7.dim("\xB7")} ${pc7.cyan(path5.relative(projectRoot, f))}`);
   }
   if (!options.yes) {
     const answer = await confirm3({
-      message: pc8.yellow(`Delete ${absoluteFiles.length} file(s) for "${slug}"?`),
+      message: pc7.yellow(`Delete ${absoluteFiles.length} file(s) for "${slug}"?`),
       initialValue: false
     });
     if (isCancel3(answer) || !answer) {
-      console.log(pc8.dim("\n  Cancelled. Nothing was removed.\n"));
+      console.log(pc7.dim("\n  Cancelled. Nothing was removed.\n"));
       return;
     }
   }
   let deleted = 0;
   for (const f of absoluteFiles) {
     try {
-      if (fs8.existsSync(f)) {
-        fs8.rmSync(f);
+      if (fs5.existsSync(f)) {
+        fs5.rmSync(f);
         deleted++;
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.log(pc8.yellow(`  \u26A0\uFE0F  Could not delete ${path8.relative(projectRoot, f)}: ${message}`));
+      console.log(pc7.yellow(`  \u26A0\uFE0F  Could not delete ${path5.relative(projectRoot, f)}: ${message}`));
     }
   }
-  const componentDir = path8.resolve(baseDir, slug);
+  const componentDir = path5.resolve(baseDir, slug);
   try {
-    if (fs8.existsSync(componentDir) && fs8.readdirSync(componentDir).length === 0) {
-      fs8.rmdirSync(componentDir);
+    if (fs5.existsSync(componentDir) && fs5.readdirSync(componentDir).length === 0) {
+      fs5.rmdirSync(componentDir);
     }
   } catch {
   }
@@ -1383,23 +956,23 @@ Remove ${slug}
     writeManifest(projectRoot, manifest);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.log(pc8.yellow(`  \u26A0\uFE0F  Removed files but failed to update vv-manifest.json: ${message}`));
+    console.log(pc7.yellow(`  \u26A0\uFE0F  Removed files but failed to update vv-manifest.json: ${message}`));
   }
   console.log("");
-  console.log(pc8.bold(pc8.green(`\u2714 Removed ${pc8.cyan(slug)} (${deleted} file(s) deleted).`)));
+  console.log(pc7.bold(pc7.green(`\u2714 Removed ${pc7.cyan(slug)} (${deleted} file(s) deleted).`)));
   if ((entry.files ?? []).length === 0) {
-    console.log(pc8.dim("  No files were tracked for this component; manifest entry cleared."));
+    console.log(pc7.dim("  No files were tracked for this component; manifest entry cleared."));
   }
   console.log("");
 }
 
 // src/commands/info.ts
-import fs9 from "fs";
-import path9 from "path";
-import pc9 from "picocolors";
-var CLI_VERSION = true ? "1.2.0" : "0.0.0-dev";
+import fs6 from "fs";
+import path6 from "path";
+import pc8 from "picocolors";
+var CLI_VERSION = true ? "2.0.1" : "0.0.0-dev";
 async function infoCommand() {
-  console.log(pc9.bold(pc9.cyan("\nVector Vesper Diagnostics\n")));
+  console.log(pc8.bold(pc8.cyan("\nVector Vesper Diagnostics\n")));
   const projectInfo = detectProject();
   let config;
   try {
@@ -1407,84 +980,84 @@ async function infoCommand() {
   } catch {
     config = null;
   }
-  console.log(pc9.bold(pc9.white("Environment:")));
-  console.log(`  \u2022 CLI Version:     ${pc9.cyan(CLI_VERSION)}`);
-  console.log(`  \u2022 Node Version:    ${pc9.cyan(process.version)}`);
-  console.log(`  \u2022 OS:              ${pc9.cyan(`${process.platform} ${process.arch}`)}`);
-  console.log(`  \u2022 Package Manager: ${pc9.cyan(projectInfo.packageManager)}`);
-  console.log(`  \u2022 Framework:       ${pc9.cyan(projectInfo.framework)}`);
-  console.log(`  \u2022 TypeScript:      ${pc9.cyan(projectInfo.isTypeScript ? "Yes" : "No")}`);
-  console.log(`  \u2022 Has src/ folder: ${pc9.cyan(projectInfo.hasSrcDir ? "Yes" : "No")}`);
-  console.log(`  \u2022 Tailwind CSS:    ${pc9.cyan(projectInfo.hasTailwind ? "Yes" : "No")}`);
+  console.log(pc8.bold(pc8.white("Environment:")));
+  console.log(`  \u2022 CLI Version:     ${pc8.cyan(CLI_VERSION)}`);
+  console.log(`  \u2022 Node Version:    ${pc8.cyan(process.version)}`);
+  console.log(`  \u2022 OS:              ${pc8.cyan(`${process.platform} ${process.arch}`)}`);
+  console.log(`  \u2022 Package Manager: ${pc8.cyan(projectInfo.packageManager)}`);
+  console.log(`  \u2022 Framework:       ${pc8.cyan(projectInfo.framework)}`);
+  console.log(`  \u2022 TypeScript:      ${pc8.cyan(projectInfo.isTypeScript ? "Yes" : "No")}`);
+  console.log(`  \u2022 Has src/ folder: ${pc8.cyan(projectInfo.hasSrcDir ? "Yes" : "No")}`);
+  console.log(`  \u2022 Tailwind CSS:    ${pc8.cyan(projectInfo.hasTailwind ? "Yes" : "No")}`);
   console.log("");
-  console.log(pc9.bold(pc9.white("Configuration (vv.config.json):")));
+  console.log(pc8.bold(pc8.white("Configuration (vv.config.json):")));
   if (config) {
-    console.log(`  \u2022 Framework Set:   ${pc9.cyan(config.framework)}`);
-    console.log(`  \u2022 TypeScript Set:  ${pc9.cyan(config.tsx ? "Yes" : "No")}`);
-    console.log(`  \u2022 Component Alias: ${pc9.cyan(config.aliases.vv)}`);
+    console.log(`  \u2022 Framework Set:   ${pc8.cyan(config.framework)}`);
+    console.log(`  \u2022 TypeScript Set:  ${pc8.cyan(config.tsx ? "Yes" : "No")}`);
+    console.log(`  \u2022 Component Alias: ${pc8.cyan(config.aliases.vv)}`);
   } else {
-    console.log(`  ${pc9.yellow("\u26A0\uFE0F  No vv.config.json found in this directory.")}`);
+    console.log(`  ${pc8.yellow("\u26A0\uFE0F  No vv.config.json found in this directory.")}`);
   }
   console.log("");
-  console.log(pc9.bold(pc9.white("Installed Components (vv-manifest.json):")));
-  const manifestPath = path9.join(process.cwd(), "vv-manifest.json");
-  if (fs9.existsSync(manifestPath)) {
+  console.log(pc8.bold(pc8.white("Installed Components (vv-manifest.json):")));
+  const manifestPath = path6.join(process.cwd(), "vv-manifest.json");
+  if (fs6.existsSync(manifestPath)) {
     try {
-      const manifest = JSON.parse(fs9.readFileSync(manifestPath, "utf-8"));
+      const manifest = JSON.parse(fs6.readFileSync(manifestPath, "utf-8"));
       const components = manifest.components || {};
       const slugs = Object.keys(components);
       if (slugs.length === 0) {
-        console.log(`  ${pc9.dim("No components installed yet.")}`);
+        console.log(`  ${pc8.dim("No components installed yet.")}`);
       } else {
-        console.log(pc9.dim("  ------------------------------------------------------------"));
-        console.log(`  ${pc9.bold(pc9.white("Component".padEnd(25)))} ${pc9.bold(pc9.white("Version".padEnd(10)))} ${pc9.bold(pc9.white("Installed At"))}`);
-        console.log(pc9.dim("  ------------------------------------------------------------"));
+        console.log(pc8.dim("  ------------------------------------------------------------"));
+        console.log(`  ${pc8.bold(pc8.white("Component".padEnd(25)))} ${pc8.bold(pc8.white("Version".padEnd(10)))} ${pc8.bold(pc8.white("Installed At"))}`);
+        console.log(pc8.dim("  ------------------------------------------------------------"));
         for (const slug of slugs) {
           const info = components[slug];
           const version2 = info?.version ?? "unknown";
           const installedAt = info?.installedAt ?? "unknown";
-          console.log(`  ${pc9.cyan(slug.padEnd(25))} ${pc9.green(version2.padEnd(10))} ${pc9.gray(installedAt)}`);
+          console.log(`  ${pc8.cyan(slug.padEnd(25))} ${pc8.green(version2.padEnd(10))} ${pc8.gray(installedAt)}`);
         }
-        console.log(pc9.dim("  ------------------------------------------------------------"));
+        console.log(pc8.dim("  ------------------------------------------------------------"));
       }
     } catch {
-      console.log(`  ${pc9.red("\u274C Error reading vv-manifest.json: Invalid JSON format.")}`);
+      console.log(`  ${pc8.red("\u274C Error reading vv-manifest.json: Invalid JSON format.")}`);
     }
   } else {
-    console.log(`  ${pc9.dim("No components installed yet (vv-manifest.json not found).")}`);
+    console.log(`  ${pc8.dim("No components installed yet (vv-manifest.json not found).")}`);
   }
   console.log("");
 }
 
 // src/commands/diff.ts
-import fs10 from "fs";
-import path10 from "path";
-import pc10 from "picocolors";
+import fs7 from "fs";
+import path7 from "path";
+import pc9 from "picocolors";
 import ora4 from "ora";
 async function diffCommand(slug) {
   const projectRoot = process.cwd();
-  const manifestPath = path10.join(projectRoot, "vv-manifest.json");
-  if (!fs10.existsSync(manifestPath)) {
-    console.log(pc10.yellow(`
+  const manifestPath = path7.join(projectRoot, "vv-manifest.json");
+  if (!fs7.existsSync(manifestPath)) {
+    console.log(pc9.yellow(`
 \u26A0\uFE0F  No vv-manifest.json found in this directory.`));
-    console.log(`\u{1F449} Add components first using ${pc10.bold(pc10.cyan("npx vectorvesper add <slug>"))}
+    console.log(`\u{1F449} Add components first using ${pc9.bold(pc9.cyan("npx vectorvesper add <slug>"))}
 `);
     return;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs10.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs7.readFileSync(manifestPath, "utf-8"));
   } catch {
-    console.error(pc10.red(`\u274C Error reading vv-manifest.json: Invalid JSON format.`));
+    console.error(pc9.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(pc10.yellow(`
+    console.log(pc9.yellow(`
 \u26A0\uFE0F  No components are registered as installed in vv-manifest.json.`));
-    console.log(`\u{1F449} Add components using ${pc10.bold(pc10.cyan("npx vectorvesper add <slug>"))}
+    console.log(`\u{1F449} Add components using ${pc9.bold(pc9.cyan("npx vectorvesper add <slug>"))}
 `);
     return;
   }
@@ -1493,21 +1066,21 @@ async function diffCommand(slug) {
       validateSlug(slug);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.error(pc10.red(`
+      console.error(pc9.red(`
 \u274C ${message}
 `));
       process.exit(1);
     }
     if (!installedComponents[slug]) {
-      console.log(pc10.red(`
+      console.log(pc9.red(`
 \u274C Component "${slug}" is not installed in this project.`));
-      console.log(`\u{1F449} Run ${pc10.cyan(`npx vectorvesper add ${slug}`)} to install it.
+      console.log(`\u{1F449} Run ${pc9.cyan(`npx vectorvesper add ${slug}`)} to install it.
 `);
       return;
     }
     const localInfo = installedComponents[slug];
     const spinner = ora4({
-      text: `Checking updates for ${pc10.cyan(slug)}...`,
+      text: `Checking updates for ${pc9.cyan(slug)}...`,
       color: "cyan"
     }).start();
     try {
@@ -1515,21 +1088,21 @@ async function diffCommand(slug) {
       spinner.stop();
       const localVersion = localInfo.version ?? "unknown";
       const remoteVersion = remoteComponent.version;
-      console.log(pc10.bold(pc10.cyan(`
+      console.log(pc9.bold(pc9.cyan(`
 Component Diff: ${slug}`)));
-      console.log(`  \u2022 Local version:  ${pc10.yellow(localVersion)}`);
-      console.log(`  \u2022 Latest version: ${pc10.green(remoteVersion)}`);
+      console.log(`  \u2022 Local version:  ${pc9.yellow(localVersion)}`);
+      console.log(`  \u2022 Latest version: ${pc9.green(remoteVersion)}`);
       if (localVersion === remoteVersion) {
-        console.log(`  \u2022 Status:         ${pc10.green("\u2714 Up to date")}
+        console.log(`  \u2022 Status:         ${pc9.green("\u2714 Up to date")}
 `);
       } else {
-        console.log(`  \u2022 Status:         ${pc10.bold(pc10.yellow("\u26A0\uFE0F  Update available!"))}`);
-        console.log(`  \u2022 Run ${pc10.bold(pc10.cyan(`npx vectorvesper add ${slug} --overwrite`))} to update.
+        console.log(`  \u2022 Status:         ${pc9.bold(pc9.yellow("\u26A0\uFE0F  Update available!"))}`);
+        console.log(`  \u2022 Run ${pc9.bold(pc9.cyan(`npx vectorvesper add ${slug} --overwrite`))} to update.
 `);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      spinner.fail(pc10.red(`Failed to fetch remote component details: ${message}`));
+      spinner.fail(pc9.red(`Failed to fetch remote component details: ${message}`));
       process.exit(1);
     }
   } else {
@@ -1540,14 +1113,14 @@ Component Diff: ${slug}`)));
     try {
       const registryIndex = await fetchRegistryIndex();
       spinner.stop();
-      console.log(pc10.bold(pc10.cyan("\nVector Vesper Component Version Comparison\n")));
-      console.log(pc10.dim("  ----------------------------------------------------------------------"));
+      console.log(pc9.bold(pc9.cyan("\nVector Vesper Component Version Comparison\n")));
+      console.log(pc9.dim("  ----------------------------------------------------------------------"));
       console.log(
-        `  ${pc10.bold(pc10.white("Component".padEnd(25)))} ${pc10.bold(
-          pc10.white("Local".padEnd(10))
-        )} ${pc10.bold(pc10.white("Latest".padEnd(10)))} ${pc10.bold(pc10.white("Status"))}`
+        `  ${pc9.bold(pc9.white("Component".padEnd(25)))} ${pc9.bold(
+          pc9.white("Local".padEnd(10))
+        )} ${pc9.bold(pc9.white("Latest".padEnd(10)))} ${pc9.bold(pc9.white("Status"))}`
       );
-      console.log(pc10.dim("  ----------------------------------------------------------------------"));
+      console.log(pc9.dim("  ----------------------------------------------------------------------"));
       let updatesAvailableCount = 0;
       for (const instSlug of installedSlugs) {
         const localInfo = installedComponents[instSlug];
@@ -1555,67 +1128,67 @@ Component Diff: ${slug}`)));
         const remoteInfo = registryIndex.components.find((c) => c.slug === instSlug);
         if (!remoteInfo) {
           console.log(
-            `  ${pc10.cyan(instSlug.padEnd(25))} ${pc10.yellow(
+            `  ${pc9.cyan(instSlug.padEnd(25))} ${pc9.yellow(
               localVersion.padEnd(10)
-            )} ${pc10.red("unknown".padEnd(10))} ${pc10.red("Not found in registry")}`
+            )} ${pc9.red("unknown".padEnd(10))} ${pc9.red("Not found in registry")}`
           );
         } else {
           const remoteVersion = remoteInfo.version;
           if (localVersion === remoteVersion) {
             console.log(
-              `  ${pc10.cyan(instSlug.padEnd(25))} ${pc10.gray(
+              `  ${pc9.cyan(instSlug.padEnd(25))} ${pc9.gray(
                 localVersion.padEnd(10)
-              )} ${pc10.gray(remoteVersion.padEnd(10))} ${pc10.green("\u2714 Up to date")}`
+              )} ${pc9.gray(remoteVersion.padEnd(10))} ${pc9.green("\u2714 Up to date")}`
             );
           } else {
             updatesAvailableCount++;
             console.log(
-              `  ${pc10.cyan(instSlug.padEnd(25))} ${pc10.yellow(
+              `  ${pc9.cyan(instSlug.padEnd(25))} ${pc9.yellow(
                 localVersion.padEnd(10)
-              )} ${pc10.green(remoteVersion.padEnd(10))} ${pc10.bold(
-                pc10.yellow("\u26A0\uFE0F  Update available")
+              )} ${pc9.green(remoteVersion.padEnd(10))} ${pc9.bold(
+                pc9.yellow("\u26A0\uFE0F  Update available")
               )}`
             );
           }
         }
       }
-      console.log(pc10.dim("  ----------------------------------------------------------------------"));
+      console.log(pc9.dim("  ----------------------------------------------------------------------"));
       if (updatesAvailableCount > 0) {
         console.log(
           `
-\u{1F4E2} ${pc10.bold(pc10.yellow(String(updatesAvailableCount)))} component(s) have updates available.`
+\u{1F4E2} ${pc9.bold(pc9.yellow(String(updatesAvailableCount)))} component(s) have updates available.`
         );
-        console.log(`\u{1F449} Run ${pc10.bold(pc10.cyan("npx vectorvesper add <slug> --overwrite"))} to update a component.
+        console.log(`\u{1F449} Run ${pc9.bold(pc9.cyan("npx vectorvesper add <slug> --overwrite"))} to update a component.
 `);
       } else {
         console.log(`
-${pc10.green("\u2714")} All components are up to date!
+${pc9.green("\u2714")} All components are up to date!
 `);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      spinner.fail(pc10.red(`Failed to check updates: ${message}`));
+      spinner.fail(pc9.red(`Failed to check updates: ${message}`));
       process.exit(1);
     }
   }
 }
 
 // src/commands/auth.ts
-import pc11 from "picocolors";
+import pc10 from "picocolors";
 async function loginCommand(key) {
   if (!key || key.trim().length === 0) {
-    logger.error("Please provide a license key.");
+    logger.error("Please provide your access token.");
     console.log(`
-  Usage: ${pc11.cyan("npx vectorvesper login <your-license-key>")}`);
-    console.log(`  \u{1F511} Get a key at ${pc11.cyan("https://vectorvesper.dev/pricing")}
+  Usage: ${pc10.cyan("npx vectorvesper login <token>")}`);
+    console.log(`  \u{1F511} Generate a token at ${pc10.cyan("https://vectorvesper.dev/account")}
 `);
     process.exit(1);
   }
   const trimmedKey = key.trim();
   if (trimmedKey.length < 8) {
-    logger.error("That doesn't look like a valid license key.");
+    logger.error("That doesn't look like a valid token.");
     console.log(`
-  \u{1F511} License keys are available at ${pc11.cyan("https://vectorvesper.dev/pricing")}
+  \u{1F511} Generate a token at ${pc10.cyan("https://vectorvesper.dev/account")}
 `);
     process.exit(1);
   }
@@ -1632,18 +1205,18 @@ async function loginCommand(key) {
     process.exit(1);
   }
   console.log("");
-  console.log(`  ${pc11.green(pc11.bold("\u2714"))} License key saved successfully!`);
-  console.log(`  ${pc11.dim("Stored at:")} ${pc11.cyan(getGlobalConfigPath())}`);
+  console.log(`  ${pc10.green(pc10.bold("\u2714"))} Token saved \u2014 you're logged in.`);
+  console.log(`  ${pc10.dim("Stored at:")} ${pc10.cyan(getGlobalConfigPath())}`);
   console.log("");
-  console.log(`  ${pc11.dim("Pro components are now available when you run")} ${pc11.cyan("npx vectorvesper add <slug>")}`);
-  console.log(`  ${pc11.dim("To verify your account:")} ${pc11.cyan("npx vectorvesper whoami")}`);
+  console.log(`  ${pc10.dim("Pro components are now available when you run")} ${pc10.cyan("npx vectorvesper add <slug>")}`);
+  console.log(`  ${pc10.dim("To verify your account:")} ${pc10.cyan("npx vectorvesper whoami")}`);
   console.log("");
 }
 async function logoutCommand() {
   const config = loadGlobalConfig();
   if (!config.auth?.token) {
     console.log(`
-  ${pc11.dim("You're not logged in. Nothing to do.")}
+  ${pc10.dim("You're not logged in. Nothing to do.")}
 `);
     return;
   }
@@ -1656,46 +1229,46 @@ async function logoutCommand() {
     process.exit(1);
   }
   console.log("");
-  console.log(`  ${pc11.green(pc11.bold("\u2714"))} Logged out successfully.`);
-  console.log(`  ${pc11.dim("Your license key has been removed from")} ${pc11.cyan(getGlobalConfigPath())}`);
-  console.log(`  ${pc11.dim("Free components remain available.")}`);
+  console.log(`  ${pc10.green(pc10.bold("\u2714"))} Logged out successfully.`);
+  console.log(`  ${pc10.dim("Your token has been removed from")} ${pc10.cyan(getGlobalConfigPath())}`);
+  console.log(`  ${pc10.dim("Free components remain available.")}`);
   console.log("");
 }
 async function whoamiCommand() {
   const config = loadGlobalConfig();
   console.log("");
-  console.log(pc11.bold(pc11.cyan("  Vector Vesper Account Status\n")));
+  console.log(pc10.bold(pc10.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(`  ${pc11.bold("Status:")}   ${pc11.green("Authenticated")}`);
-    console.log(`  ${pc11.bold("Key:")}      ${pc11.cyan(maskedKey)}`);
-    console.log(`  ${pc11.bold("Tier:")}     ${pc11.magenta(tier)}`);
+    console.log(`  ${pc10.bold("Status:")}   ${pc10.green("Authenticated")}`);
+    console.log(`  ${pc10.bold("Token:")}    ${pc10.cyan(maskedKey)}`);
+    console.log(`  ${pc10.bold("Tier:")}     ${pc10.magenta(tier)}`);
     if (config.auth.email) {
-      console.log(`  ${pc11.bold("Email:")}    ${pc11.cyan(config.auth.email)}`);
+      console.log(`  ${pc10.bold("Email:")}    ${pc10.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(`  ${pc11.bold("Expires:")}  ${isExpired ? pc11.red("EXPIRED") : pc11.green(expiry.toLocaleDateString())}`);
+      console.log(`  ${pc10.bold("Expires:")}  ${isExpired ? pc10.red("EXPIRED") : pc10.green(expiry.toLocaleDateString())}`);
     }
     console.log("");
-    console.log(`  ${pc11.dim("Config:")} ${pc11.cyan(getGlobalConfigPath())}`);
-    console.log(`  ${pc11.dim("Manage your account at")} ${pc11.cyan("https://vectorvesper.dev/account")}`);
+    console.log(`  ${pc10.dim("Config:")} ${pc10.cyan(getGlobalConfigPath())}`);
+    console.log(`  ${pc10.dim("Manage your account at")} ${pc10.cyan("https://vectorvesper.dev/account")}`);
   } else {
-    console.log(`  ${pc11.bold("Status:")}   ${pc11.yellow("Anonymous (free tier)")}`);
-    console.log(`  ${pc11.bold("Access:")}   ${pc11.dim("Free components only")}`);
+    console.log(`  ${pc10.bold("Status:")}   ${pc10.yellow("Anonymous (free tier)")}`);
+    console.log(`  ${pc10.bold("Access:")}   ${pc10.dim("Free components only")}`);
     console.log("");
-    console.log(`  ${pc11.dim("To unlock pro components:")}`);
-    console.log(`  ${pc11.cyan("npx vectorvesper login <your-license-key>")}`);
-    console.log(`  \u{1F511} ${pc11.dim("Get a key at")} ${pc11.cyan("https://vectorvesper.dev/pricing")}`);
+    console.log(`  ${pc10.dim("To unlock pro components:")}`);
+    console.log(`  ${pc10.cyan("npx vectorvesper login <token>")}`);
+    console.log(`  \u{1F511} ${pc10.dim("Generate a token at")} ${pc10.cyan("https://vectorvesper.dev/account")}`);
   }
   console.log("");
 }
 
 // src/index.ts
-var version = true ? "1.2.0" : "0.0.0-dev";
+var version = true ? "2.0.1" : "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();
@@ -1733,6 +1306,10 @@ program.command("logout", { hidden: true }).description("Clear stored license cr
 program.command("whoami", { hidden: true }).description("Show current authentication status").action(async () => {
   await whoamiCommand();
 });
+program.command("mcp [action]").description("Run as an MCP server (stdio) for AI coding agents. `vv mcp status` checks the setup.").option("--stdio", "Force server mode even from an interactive terminal").action(async (action, options) => {
+  const { mcpCommand } = await import("./mcp-ZGA5K5VW.js");
+  await mcpCommand(action, options);
+});
 process.on("unhandledRejection", (error) => {
   console.error("An unexpected error occurred:", error instanceof Error ? error.message : error);
   process.exit(1);