@glass-ui-kit/cli 0.2.5 → 1.0.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command3 } from "commander";
+import { Command as Command6 } from "commander";
 
 // src/commands/init.ts
 import chalk2 from "chalk";
@@ -122,8 +122,20 @@ function exists(filePath, baseDir = process.cwd()) {
 }
 
 // src/utils/get-project-info.ts
+import path4 from "path";
 import { spawn } from "child_process";
+function resolveProjectRoot(cwdOption, cwd = process.cwd()) {
+  return cwdOption ? path4.resolve(cwd, cwdOption) : cwd;
+}
+function getLockfilePath(projectRoot = process.cwd(), existsAtPath = exists) {
+  if (existsAtPath("bun.lock", projectRoot)) return "bun.lock";
+  if (existsAtPath("bun.lockb", projectRoot)) return "bun.lockb";
+  if (existsAtPath("pnpm-lock.yaml", projectRoot)) return "pnpm-lock.yaml";
+  if (existsAtPath("yarn.lock", projectRoot)) return "yarn.lock";
+  return null;
+}
 async function getPackageManager(projectRoot = process.cwd()) {
+  if (exists("bun.lock", projectRoot)) return "bun";
   if (exists("bun.lockb", projectRoot)) return "bun";
   if (exists("pnpm-lock.yaml", projectRoot)) return "pnpm";
   if (exists("yarn.lock", projectRoot)) return "yarn";
@@ -519,7 +531,7 @@ import chalk4 from "chalk";
 import { Command as Command2 } from "commander";
 
 // src/utils/registry.ts
-import path4 from "path";
+import path5 from "path";
 import os from "os";
 import fs2 from "fs/promises";
 
@@ -553,8 +565,8 @@ var registryIndexSchema = z.array(registryItemSchema);
 
 // src/utils/registry.ts
 var DEFAULT_REGISTRY_URL = "https://ui-glass.vercel.app/registry.json";
-var CACHE_DIR = path4.join(os.homedir(), ".glass-ui");
-var CACHE_FILE = path4.join(CACHE_DIR, "registry.json");
+var CACHE_DIR = path5.join(os.homedir(), ".glass-ui");
+var CACHE_FILE = path5.join(CACHE_DIR, "registry.json");
 var CACHE_TTL = 1e3 * 60 * 60 * 24;
 function getRegistryUrl() {
   return process.env.GLASS_UI_REGISTRY_URL || DEFAULT_REGISTRY_URL;
@@ -585,6 +597,12 @@ async function writeCache(data) {
   } catch {
   }
 }
+function getErrorMessage(error, fallback) {
+  if (error instanceof Error && error.message.length > 0) {
+    return error.message;
+  }
+  return fallback;
+}
 async function fetchRegistry() {
   const cachedRegistry = await readCache();
   if (cachedRegistry) {
@@ -595,7 +613,7 @@ async function fetchRegistry() {
   try {
     response = await fetch(url);
   } catch (error) {
-    throw new Error("Network error: Unable to connect to registry. Check your internet connection.");
+    throw new Error(getErrorMessage(error, "Network error: Unable to connect to registry."));
   }
   if (!response.ok) {
     throw new Error(`Registry unavailable. URL: ${url} (Status: ${response.status})`);
@@ -603,15 +621,14 @@ async function fetchRegistry() {
   let data;
   try {
     data = await response.json();
-  } catch {
-    throw new Error("Invalid response: Registry returned non-JSON data.");
+  } catch (error) {
+    throw new Error(getErrorMessage(error, "Invalid response: Registry returned non-JSON data."));
   }
   const parsed = registryIndexSchema.safeParse(data);
   if (!parsed.success) {
-    console.error("Debug: Schema validation errors:", parsed.error.flatten());
-    throw new Error(
-      "Incompatible registry version. Your CLI might be outdated. Please try updating @glass-ui-kit/cli."
-    );
+    const issue = parsed.error.issues[0];
+    const location = issue?.path.length ? issue.path.join(".") : "registry";
+    throw new Error(`${issue?.message ?? "Schema validation failed"}: ${location}`);
   }
   await writeCache(parsed.data);
   return parsed.data;
@@ -697,7 +714,7 @@ function resolveTargetDir(config, hasSrc, explicitPath) {
 }
 
 // src/utils/add/planner.ts
-import path5 from "path";
+import path6 from "path";
 
 // src/utils/transformers.ts
 function transformImports(content, config) {
@@ -725,8 +742,8 @@ function buildWritePlan(items, config, hasSrc, options) {
   const targetDir = resolveTargetDir(config, hasSrc, options.path);
   return items.flatMap(
     (item) => item.files.filter((file) => Boolean(file.content)).map((file) => {
-      const fileName = path5.basename(file.path);
-      const filePath = path5.join(targetDir, fileName);
+      const fileName = path6.basename(file.path);
+      const filePath = path6.join(targetDir, fileName);
       return {
         filePath,
         content: transformImports(file.content || "", config),
@@ -737,7 +754,7 @@ function buildWritePlan(items, config, hasSrc, options) {
 }
 
 // src/utils/add/run-add.ts
-import path6 from "path";
+import path7 from "path";
 import chalk3 from "chalk";
 var defaultRuntime2 = {
   cwd: () => process.cwd(),
@@ -752,11 +769,11 @@ var defaultRuntime2 = {
 function buildMissingComponentsMessage(names) {
   return `Components not found: ${names.join(", ")}.`;
 }
-function resolveProjectRoot(cwdOption, cwd) {
-  return cwdOption ? path6.resolve(cwd, cwdOption) : cwd;
+function resolveProjectRoot2(cwdOption, cwd) {
+  return cwdOption ? path7.resolve(cwd, cwdOption) : cwd;
 }
 async function runAddCommand(componentNames = [], options = {}, runtime = defaultRuntime2) {
-  const projectRoot = resolveProjectRoot(options.cwd, runtime.cwd?.() ?? process.cwd());
+  const projectRoot = resolveProjectRoot2(options.cwd, runtime.cwd?.() ?? process.cwd());
   if (options.depsOnly && options.install === false) {
     throw new Error("invalid-install-combination");
   }
@@ -878,9 +895,383 @@ function createAddAction(deps = {
 }
 var add = new Command2().name("add").description("Add one or more components to your project").argument("[components...]", "The components to add").option("--all", "Add all available components").option("--overwrite", "Replace existing component files").option("--path <dir>", "Use a custom output directory").option("--no-install", "Skip dependency installation").option("--deps-only", "Install dependencies without writing component files").option("--cwd <path>", "Run the command against another project directory").action(createAddAction());
 
+// src/commands/list.ts
+import chalk5 from "chalk";
+import { Command as Command3 } from "commander";
+
+// src/utils/list/run-list.ts
+var defaultRuntime3 = {
+  fetchRegistry
+};
+async function runListCommand(options = {}, runtime = defaultRuntime3) {
+  const registry = await runtime.fetchRegistry();
+  if (options.json) {
+    return JSON.stringify(registry, null, 2);
+  }
+  return registry.map((item) => item.name).join("\n");
+}
+
+// src/commands/list.ts
+async function runListCommand2(options = {}, runtime = defaultRuntime3) {
+  return runListCommand(options, runtime);
+}
+function createListAction(deps = {
+  runListCommand: runListCommand2,
+  error: console.error,
+  log: console.log,
+  exit: process.exit
+}) {
+  return async (options = {}) => {
+    try {
+      const output = await deps.runListCommand({ json: options.json === true });
+      if (output.length > 0) {
+        deps.log(output);
+      }
+    } catch (error) {
+      deps.error(chalk5.red("\nList failed:"));
+      if (error instanceof Error) {
+        deps.error(chalk5.gray(error.message));
+      } else {
+        deps.error(chalk5.gray(String(error)));
+      }
+      deps.exit(1);
+    }
+  };
+}
+var list = new Command3().name("list").description("List available components from the registry").option("--json", "Output the validated registry payload as JSON", false).action(createListAction());
+
+// src/commands/info.ts
+import chalk6 from "chalk";
+import { Command as Command4 } from "commander";
+
+// src/utils/info/format-info.ts
+function formatDependencySection(label, values) {
+  return `${label}: ${values && values.length > 0 ? values.join(", ") : "None"}`;
+}
+function formatInfo(item) {
+  const lines = [
+    `Name: ${item.name}`,
+    `Type: ${item.type}`,
+    "Files:",
+    ...item.files.map((file) => `- ${file.path} (${file.type})`),
+    formatDependencySection("Dependencies", item.dependencies),
+    formatDependencySection("Dev Dependencies", item.devDependencies),
+    formatDependencySection("Registry Dependencies", item.registryDependencies)
+  ];
+  if (item.meta?.requiresBlur !== void 0) {
+    lines.push(`Requires Blur: ${item.meta.requiresBlur}`);
+  }
+  return lines.join("\n");
+}
+
+// src/utils/info/run-info.ts
+var defaultRuntime4 = {
+  fetchRegistry,
+  getItem
+};
+async function runInfoCommand(componentName, options = {}, runtime = defaultRuntime4) {
+  const registry = await runtime.fetchRegistry();
+  const item = runtime.getItem(registry, componentName);
+  if (!item) {
+    throw new Error(`Component not found: "${componentName}"`);
+  }
+  if (options.json) {
+    return JSON.stringify(item, null, 2);
+  }
+  return formatInfo(item);
+}
+
+// src/commands/info.ts
+async function runInfoCommand2(componentName, options = {}, runtime = defaultRuntime4) {
+  return runInfoCommand(componentName, options, runtime);
+}
+function createInfoAction(deps = {
+  runInfoCommand: runInfoCommand2,
+  error: console.error,
+  log: console.log,
+  exit: process.exit
+}) {
+  return async (componentName, options = {}) => {
+    try {
+      const output = await deps.runInfoCommand(componentName, { json: options.json === true });
+      if (output.length > 0) {
+        deps.log(output);
+      }
+    } catch (error) {
+      deps.error(chalk6.red("\nInfo failed:"));
+      if (error instanceof Error) {
+        deps.error(chalk6.gray(error.message));
+      } else {
+        deps.error(chalk6.gray(String(error)));
+      }
+      deps.exit(1);
+    }
+  };
+}
+var info = new Command4().name("info").description("Show details for a single registry component").argument("<component>", "The exact component name to inspect").option("--json", "Output the validated registry item as JSON", false).action(createInfoAction());
+
+// src/commands/doctor.ts
+import chalk7 from "chalk";
+import { Command as Command5 } from "commander";
+
+// src/utils/doctor/format-doctor.ts
+function formatCheck(check) {
+  const icon = check.status === "ok" ? "\u2713" : check.status === "warn" ? "!" : "\u2716";
+  const lines = [`${icon} ${check.id} \u2014 ${check.summary}`];
+  if (check.detail) {
+    lines.push(`  Next step: ${check.detail}`);
+  }
+  return lines.join("\n");
+}
+function formatDoctorReport(report) {
+  const aliasLine = report.config.aliases ? `- Aliases: components=${report.config.aliases.components}, utils=${report.config.aliases.utils}` : "- Aliases: missing";
+  return [
+    "Glass UI Doctor",
+    `Project root: ${report.projectRoot}`,
+    `Init readiness: ${report.readiness.init ? "ready" : "not ready"}`,
+    `Add readiness: ${report.readiness.add ? "ready" : "not ready"}`,
+    "",
+    "Detected state:",
+    `- Framework: ${report.framework.value} (${report.framework.source})`,
+    `- Package manager: ${report.packageManager.value} (${report.packageManager.source})`,
+    `- Config: ${report.config.path} (${report.config.source})`,
+    `- CSS: ${report.css.path ?? "unresolved"} (${report.css.source}, ${report.css.exists ? "exists" : "missing"})`,
+    aliasLine,
+    "",
+    "Checks:",
+    ...report.checks.map(formatCheck)
+  ].join("\n");
+}
+
+// src/utils/doctor/inspect-project.ts
+import { z as z2 } from "zod";
+var configSchema = z2.object({
+  framework: z2.enum(["react", "next", "vite", "astro", "remix", "unknown"]),
+  style: z2.string(),
+  css: z2.string().min(1),
+  aliases: z2.object({
+    components: z2.string().min(1),
+    utils: z2.string().min(1)
+  })
+});
+function buildChecks(report) {
+  const checks = [];
+  if (report.config.source === "detected") {
+    checks.push({ id: "config", status: "ok", summary: "Found valid glass.config.json." });
+  } else if (report.config.source === "missing") {
+    checks.push({
+      id: "config",
+      status: "error",
+      summary: "glass.config.json was not found.",
+      detail: "Run `glass-ui init` in this project before running `glass-ui add`."
+    });
+  } else {
+    checks.push({
+      id: "config",
+      status: "error",
+      summary: "glass.config.json is invalid.",
+      detail: report.config.error ?? "Fix the config JSON and try doctor again."
+    });
+  }
+  if (report.framework.source === "detected") {
+    checks.push({
+      id: "framework",
+      status: "ok",
+      summary: `Detected framework: ${report.framework.value}.`
+    });
+  } else {
+    checks.push({
+      id: "framework",
+      status: "warn",
+      summary: `Could not confidently detect the framework; using ${report.framework.value}.`,
+      detail: "Check package.json dependencies or pass an explicit framework during `glass-ui init`."
+    });
+  }
+  if (report.packageManager.source === "detected") {
+    checks.push({
+      id: "package-manager",
+      status: "ok",
+      summary: `Detected package manager: ${report.packageManager.value}.`
+    });
+  } else {
+    checks.push({
+      id: "package-manager",
+      status: "warn",
+      summary: `No lockfile found; defaulting to ${report.packageManager.value}.`,
+      detail: "Create or commit the lockfile used by this project to confirm the package manager."
+    });
+  }
+  if (report.css.path && report.css.exists && report.css.source === "detected") {
+    checks.push({
+      id: "css",
+      status: "ok",
+      summary: `CSS file is available at ${report.css.path}.`
+    });
+  } else if (report.css.path && report.css.exists) {
+    checks.push({
+      id: "css",
+      status: "warn",
+      summary: `CSS path was inferred as ${report.css.path}.`,
+      detail: "Save the CSS path in glass.config.json to confirm it explicitly."
+    });
+  } else if (report.css.path) {
+    checks.push({
+      id: "css",
+      status: "warn",
+      summary: `CSS file is missing at ${report.css.path}.`,
+      detail: "Create the CSS file or update glass.config.json to point at the correct path."
+    });
+  } else {
+    checks.push({
+      id: "css",
+      status: "warn",
+      summary: "Could not resolve a CSS file path.",
+      detail: "Set the css field in glass.config.json or rerun `glass-ui init`."
+    });
+  }
+  if (report.config.aliases) {
+    checks.push({
+      id: "aliases",
+      status: "ok",
+      summary: "Detected components and utils aliases."
+    });
+  } else {
+    checks.push({
+      id: "aliases",
+      status: "error",
+      summary: "Components and utils aliases are missing.",
+      detail: "Save both aliases in glass.config.json so generated imports resolve correctly."
+    });
+  }
+  if (report.readiness.add) {
+    checks.push({ id: "add-readiness", status: "ok", summary: "Project is ready for add." });
+  } else {
+    checks.push({
+      id: "add-readiness",
+      status: "error",
+      summary: "Project is not ready for add.",
+      detail: "Create a valid glass.config.json with aliases before adding components."
+    });
+  }
+  return checks;
+}
+async function inspectProject(options = {}, runtime) {
+  const projectRoot = resolveProjectRoot(options.cwd, runtime.cwd());
+  if (!runtime.exists(".", projectRoot)) {
+    throw new Error(
+      `Could not inspect directory "${projectRoot}": path does not exist or is not accessible.`
+    );
+  }
+  const hasPackageJson = runtime.exists("package.json", projectRoot);
+  const frameworkValue = await runtime.getFramework(projectRoot);
+  const frameworkSource = hasPackageJson && frameworkValue !== "unknown" ? "detected" : "inferred";
+  const packageManagerValue = await runtime.getPackageManager(projectRoot);
+  const packageManagerSource = getLockfilePath(projectRoot, runtime.exists) ? "detected" : "inferred";
+  let config = {
+    path: "glass.config.json",
+    source: "missing"
+  };
+  if (runtime.exists("glass.config.json", projectRoot)) {
+    try {
+      const parsed = configSchema.parse(
+        JSON.parse(await runtime.readFile("glass.config.json", projectRoot))
+      );
+      config = {
+        path: "glass.config.json",
+        source: "detected",
+        css: parsed.css,
+        aliases: parsed.aliases
+      };
+    } catch (error) {
+      config = {
+        path: "glass.config.json",
+        source: "invalid",
+        error: error instanceof Error ? `Invalid config: ${error.message}` : "Invalid config."
+      };
+    }
+  }
+  const cssPath = config.css ?? runtime.getCssPath(frameworkValue, projectRoot);
+  const cssSource = config.css ? "detected" : cssPath ? "inferred" : "missing";
+  const cssExists = cssPath ? runtime.exists(cssPath, projectRoot) : false;
+  const readiness = {
+    init: true,
+    add: config.source === "detected" && Boolean(config.aliases?.components) && Boolean(config.aliases?.utils)
+  };
+  const reportWithoutChecks = {
+    projectRoot,
+    framework: { value: frameworkValue, source: frameworkSource },
+    packageManager: { value: packageManagerValue, source: packageManagerSource },
+    config,
+    css: {
+      path: cssPath,
+      exists: cssExists,
+      source: cssSource
+    },
+    readiness
+  };
+  return {
+    ...reportWithoutChecks,
+    checks: buildChecks(reportWithoutChecks)
+  };
+}
+
+// src/utils/doctor/run-doctor.ts
+var defaultRuntime5 = {
+  cwd: () => process.cwd(),
+  exists,
+  readFile,
+  writeFile,
+  getFramework,
+  getPackageManager,
+  getCssPath,
+  installDependencies,
+  inspectProject,
+  formatDoctorReport
+};
+async function runDoctorCommand(options = {}, runtime = defaultRuntime5) {
+  const resolvedRuntime = { ...defaultRuntime5, ...runtime };
+  const report = await resolvedRuntime.inspectProject(options, resolvedRuntime);
+  if (options.json) {
+    return JSON.stringify(report, null, 2);
+  }
+  return resolvedRuntime.formatDoctorReport(report);
+}
+
+// src/commands/doctor.ts
+async function runDoctorCommand2(options = {}, runtime = defaultRuntime5) {
+  return runDoctorCommand(options, runtime);
+}
+function createDoctorAction(deps = {
+  runDoctorCommand: runDoctorCommand2,
+  error: console.error,
+  log: console.log,
+  exit: process.exit
+}) {
+  return async (options = {}) => {
+    try {
+      const output = await deps.runDoctorCommand({ cwd: options.cwd, json: options.json === true });
+      if (output.length > 0) {
+        deps.log(output);
+      }
+    } catch (error) {
+      deps.error(chalk7.red("\nDoctor failed:"));
+      if (error instanceof Error) {
+        deps.error(chalk7.gray(error.message));
+      } else {
+        deps.error(chalk7.gray(String(error)));
+      }
+      deps.exit(1);
+    }
+  };
+}
+var doctor = new Command5().name("doctor").description("Diagnose whether a project is ready to use the CLI").option("--cwd <path>", "Run the command against another project directory").option("--json", "Output the diagnostic report as JSON", false).action(createDoctorAction());
+
 // src/index.ts
-var program = new Command3();
+var program = new Command6();
 program.name("glass-ui").description("The Glass UI CLI - Add glassmorphism components to your app").version("0.2.5");
 program.addCommand(init);
 program.addCommand(add);
+program.addCommand(list);
+program.addCommand(info);
+program.addCommand(doctor);
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glass-ui-kit/cli",
-  "version": "0.2.5",
+  "version": "1.0.0",
   "description": "The official CLI for Glass UI. Add glassmorphism components to your React projects in seconds.",
   "keywords": [
     "glassmorphism",
@@ -20,7 +20,7 @@
     "directory": "packages/cli"
   },
   "license": "MIT",
-  "author": "Glass UI Team",
+  "author": "jntellez (https://jntellez.dev)",
   "type": "module",
   "bin": {
     "glass-ui": "./dist/index.js"
@@ -44,8 +44,8 @@
     "vitest": "^3.2.4",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
-    "@glass-ui-kit/schema": "0.0.1",
-    "@glass-ui-kit/tsconfig": "0.0.1"
+    "@glass-ui-kit/tsconfig": "0.0.1",
+    "@glass-ui-kit/schema": "0.0.1"
   },
   "publishConfig": {
     "access": "public"