vectorvesper 1.2.0 → 2.0.0

package/dist/chunk-32GDEAJM.js

@@ -0,0 +1,498 @@
+// 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/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 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(),
+  // These are emitted by the registry build and were reaching consumers only
+  // through .passthrough(), i.e. typed as unknown. Declared optional rather
+  // than required so an older published registry still validates.
+  fallbacks: z.array(z.string()).optional(),
+  recipes: z.array(z.string()).optional(),
+  docsUrl: z.string().optional(),
+  previewUrl: z.string().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/utils/registry.ts
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/vectorvesper/vv-components/main/r";
+var DEFAULT_PRO_API_URL = "https://vectorvesper.dev/api/cli/registry";
+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 getProApiBaseUrl() {
+  return process.env.VV_PRO_API_URL || DEFAULT_PRO_API_URL;
+}
+function handleHttpError(status, url) {
+  switch (status) {
+    case 401:
+      throw new Error(
+        `Authentication required. This is a Pro component.
+\u{1F449} Run "npx vectorvesper login <token>" \u2014 get a token at https://vectorvesper.dev/account
+\u{1F511} Pro membership: https://vectorvesper.dev/pricing`
+      );
+    case 402:
+      throw new Error(
+        `This is a Pro component and requires an active membership.
+\u{1F449} Upgrade at https://vectorvesper.dev/pricing
+\u{1F4A1} Run "npx vectorvesper list" to see all free components.`
+      );
+    case 403:
+      throw new Error(
+        `Access denied. Your membership doesn't include this component, or it has lapsed.
+\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 = path3.resolve(cleanPath);
+  if (!fs3.existsSync(cleanPath)) {
+    throw new Error(`Registry path not found: ${cleanPath}`);
+  }
+  logger.debug(`Reading local registry: ${cleanPath}`);
+  return fs3.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;
+}
+var indexCache = null;
+async function getCachedIndex() {
+  if (indexCache) return indexCache;
+  try {
+    indexCache = await fetchRegistryIndex();
+  } catch {
+    return null;
+  }
+  return indexCache;
+}
+async function getComponentTier(slug) {
+  const index = await getCachedIndex();
+  return index?.components.find((c) => c.slug === slug)?.tier;
+}
+async function fetchComponent(slug) {
+  validateSlug(slug);
+  const tier = await getComponentTier(slug);
+  return tier === "pro" ? fetchProComponent(slug) : fetchFreeComponent(slug);
+}
+async function fetchFreeComponent(slug) {
+  const baseUrl = getRegistryBaseUrl();
+  const url = baseUrl.endsWith("/") ? `${baseUrl}${slug}.json` : `${baseUrl}/${slug}.json`;
+  return parseComponent(slug, await fetchRegistryData(url));
+}
+async function fetchProComponent(slug) {
+  if (!getAuthToken()) {
+    throw new Error(
+      `"${slug}" is a Pro component and needs authentication.
+\u{1F449} Run "npx vectorvesper login <token>" \u2014 get a token at https://vectorvesper.dev/account
+\u{1F511} Pro membership: https://vectorvesper.dev/pricing`
+    );
+  }
+  const base = getProApiBaseUrl();
+  const url = base.endsWith("/") ? `${base}${slug}` : `${base}/${slug}`;
+  return parseComponent(slug, await fetchRegistryData(url));
+}
+function parseComponent(slug, content) {
+  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;
+}
+
+export {
+  setVerbose,
+  logger,
+  detectProject,
+  validateSlug,
+  loadConfig,
+  writeConfig,
+  getGlobalConfigPath,
+  loadGlobalConfig,
+  saveGlobalConfig,
+  getAuthToken,
+  resolveAlias,
+  fetchRegistryIndex,
+  fetchComponent
+};