@hemia/lume 0.0.1

package/README.md

@@ -0,0 +1,109 @@
+# @hemia/lume
+
+CLI for adding Lume UI components to your project. Inspired by shadcn/ui.
+
+## Quick start
+
+```bash
+bunx @hemia/lume@latest init
+bunx @hemia/lume@latest add button
+```
+
+## Commands
+
+### `init`
+
+Initialize Lume in your project:
+
+```bash
+bunx @hemia/lume@latest init
+
+# With template
+bunx @hemia/lume@latest init -t nuxt
+
+# With preset
+bunx @hemia/lume@latest init --preset dashboard
+```
+
+Creates `lume.config.json` and sets up Tailwind configuration.
+
+### `add`
+
+Add components to your project:
+
+```bash
+# Single component
+bunx @hemia/lume@latest add button
+
+# Multiple components
+bunx @hemia/lume@latest add button card badge
+
+# All components
+bunx @hemia/lume@latest add --all
+
+# Skip confirmation
+bunx @hemia/lume@latest add button -y
+```
+
+Components are **copied to your project** (not installed from npm).
+
+### `list`
+
+List available components:
+
+```bash
+bunx @hemia/lume@latest list
+
+# For specific framework
+bunx @hemia/lume@latest list --framework react
+```
+
+## How it works
+
+1. Components are stored in `@hemia/lume-registry`
+2. CLI detects your framework from `lume.config.json`
+3. Copies component files to `src/components/ui/`
+4. Installs required dependencies automatically
+
+## Framework support
+
+- ✅ **Vue 3** — Full support
+- 🚧 **React** — Coming soon
+- 🚧 **Svelte** — Coming soon
+- 🚧 **Astro** — Coming soon
+
+## Configuration
+
+The `lume.config.json` file:
+
+```json
+{
+  "framework": "vue",
+  "style": "default",
+  "template": "vite-vue",
+  "tailwind": {
+    "config": "tailwind.config.ts",
+    "css": "src/assets/globals.css"
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils"
+  }
+}
+```
+
+## Templates
+
+- `vite-vue` — Vite + Vue 3
+- `nuxt` — Nuxt 3
+- `next` — Next.js (coming soon)
+
+## Presets
+
+- `dashboard` — Button, Card, Input, Select, Table, Chart
+- `auth` — Button, Input, Card, Form
+- `landing` — Button, Card, Hero, Features, CTA
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,603 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/add.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+import pc2 from "picocolors";
+import prompts from "prompts";
+import { createRequire } from "module";
+
+// src/utils/package-manager.ts
+import fs from "fs-extra";
+import path from "path";
+import { execSync } from "child_process";
+import pc from "picocolors";
+function detectPackageManager(cwd = process.cwd()) {
+  if (fs.existsSync(path.join(cwd, "bun.lockb"))) return "bun";
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function getInstallCommand(packageManager) {
+  const commands = {
+    bun: "bun add",
+    pnpm: "pnpm add",
+    yarn: "yarn add",
+    npm: "npm install"
+  };
+  return commands[packageManager];
+}
+function installDependencies(dependencies, options = {}) {
+  if (dependencies.length === 0) return;
+  const { dev = false, cwd = process.cwd() } = options;
+  const packageManager = detectPackageManager(cwd);
+  const installCmd = getInstallCommand(packageManager);
+  const devFlag = dev ? packageManager === "npm" ? "--save-dev" : "-D" : "";
+  const command = `${installCmd} ${dependencies.join(" ")} ${devFlag}`.trim();
+  console.log(pc.cyan(`\u{1F4E6} Installing dependencies with ${packageManager}...`));
+  console.log(pc.dim(`   ${command}`));
+  try {
+    execSync(command, { cwd, stdio: "inherit" });
+    console.log(pc.green("\u2705 Dependencies installed successfully"));
+  } catch (error) {
+    console.log(pc.yellow("\u26A0\uFE0F  Failed to install dependencies. Please install manually:"));
+    console.log(pc.dim(`   ${command}`));
+  }
+}
+
+// src/utils/registry.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+async function readComponentMeta(componentPath) {
+  const metaPath = path2.join(componentPath, "meta.json");
+  if (!await fs2.pathExists(metaPath)) {
+    return null;
+  }
+  try {
+    return await fs2.readJson(metaPath);
+  } catch {
+    return null;
+  }
+}
+async function getAllDependencies(componentName, registryPath, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(componentName)) {
+    return { components: [], dependencies: [], devDependencies: [] };
+  }
+  visited.add(componentName);
+  const componentPath = path2.join(registryPath, componentName);
+  const meta = await readComponentMeta(componentPath);
+  if (!meta) {
+    return { components: [], dependencies: [], devDependencies: [] };
+  }
+  const components = [componentName];
+  const dependencies = [...meta.dependencies || [], ...meta.peerDependencies || []];
+  const devDependencies = [...meta.devDependencies || []];
+  if (meta.registryDependencies && meta.registryDependencies.length > 0) {
+    for (const depName of meta.registryDependencies) {
+      const depResult = await getAllDependencies(depName, registryPath, visited);
+      components.push(...depResult.components);
+      dependencies.push(...depResult.dependencies);
+      devDependencies.push(...depResult.devDependencies);
+    }
+  }
+  return {
+    components: [...new Set(components)],
+    dependencies: [...new Set(dependencies)],
+    devDependencies: [...new Set(devDependencies)]
+  };
+}
+
+// src/commands/add.ts
+var require2 = createRequire(import.meta.url);
+function resolveRegistryPath(framework) {
+  const registryRoot = path3.dirname(
+    require2.resolve("@hemia/lume-registry/package.json")
+  );
+  return path3.join(registryRoot, "registry", framework);
+}
+function getFrameworkFromConfig(cwd) {
+  try {
+    const config = fs3.readJsonSync(path3.resolve(cwd, "lume.config.json"));
+    return config.framework ?? "vue";
+  } catch {
+    return "vue";
+  }
+}
+function log(message, options) {
+  if (!options.silent) {
+    console.log(message);
+  }
+}
+function warn(message, options) {
+  if (!options.silent) {
+    console.log(pc2.yellow(`\u26A0\uFE0F  ${message}`));
+  }
+}
+async function add(components = [], options = {}) {
+  if (options.dryRun) {
+    warn("Dry-run option is not implemented yet. Coming soon!", options);
+  }
+  if (options.diff) {
+    warn("Diff option is not implemented yet. Coming soon!", options);
+  }
+  if (options.view) {
+    warn("View option is not implemented yet. Coming soon!", options);
+  }
+  const cwd = options.cwd ? path3.resolve(options.cwd) : process.cwd();
+  const targetBase = options.path ? path3.resolve(cwd, options.path) : path3.resolve(cwd, "src/components/ui");
+  const componentNames = options.all ? ["button", "card", "badge", "alert", "field", "icon", "textfield", "alert-dialog"] : Array.isArray(components) ? components : components ? [components] : [];
+  if (componentNames.length === 0 && !options.all) {
+    log("No components specified. Use --all to add all components or specify component names.", options);
+    process.exit(1);
+  }
+  const framework = options.framework ?? getFrameworkFromConfig(cwd);
+  const frameworkRegistry = resolveRegistryPath(framework);
+  if (!options.silent) {
+    log(pc2.cyan(`
+\u26A1 Adding component(s) to ${targetBase}/
+`), options);
+  }
+  const allComponents = /* @__PURE__ */ new Set();
+  const allDependencies = /* @__PURE__ */ new Set();
+  const allDevDependencies = /* @__PURE__ */ new Set();
+  for (const name of componentNames) {
+    const componentPath = path3.join(frameworkRegistry, name);
+    if (!await fs3.pathExists(componentPath)) {
+      log(pc2.red(`\u274C Component "${name}" not found in registry for framework "${framework}"`), options);
+      process.exit(1);
+    }
+    const result = await getAllDependencies(name, frameworkRegistry);
+    result.components.forEach((c) => allComponents.add(c));
+    result.dependencies.forEach((d) => allDependencies.add(d));
+    result.devDependencies.forEach((d) => allDevDependencies.add(d));
+  }
+  const componentsArray = Array.from(allComponents);
+  log(pc2.cyan(`\u{1F4E6} Components to install (${componentsArray.length}):`), options);
+  log(pc2.dim(`   ${componentsArray.join(", ")}
+`), options);
+  await fs3.ensureDir(targetBase);
+  let copiedCount = 0;
+  for (const componentName of componentsArray) {
+    const source = path3.join(frameworkRegistry, componentName);
+    const target = path3.join(targetBase, `${componentName}.vue`);
+    const targetExists = await fs3.pathExists(target);
+    if (targetExists && !options.overwrite && !options.yes) {
+      const { overwrite } = await prompts({
+        type: "confirm",
+        name: "overwrite",
+        message: pc2.yellow(`Component "${componentName}" already exists. Overwrite?`),
+        initial: false
+      });
+      if (!overwrite) {
+        log(pc2.dim(`   Skipped ${componentName}`), options);
+        continue;
+      }
+    }
+    if (options.overwrite || options.yes || !targetExists) {
+      await fs3.copy(source, target, { overwrite: true });
+      copiedCount++;
+      log(pc2.green(`   \u2713 ${componentName}`), options);
+    }
+  }
+  const deps = Array.from(allDependencies);
+  const devDeps = Array.from(allDevDependencies);
+  if (deps.length > 0) {
+    log("", options);
+    installDependencies(deps);
+  }
+  if (devDeps.length > 0) {
+    log("", options);
+    installDependencies(devDeps, { dev: true });
+  }
+  log(pc2.green(`
+\u2705 Added ${copiedCount} component(s) to ${targetBase}/`), options);
+}
+
+// src/commands/init.ts
+import fs4 from "fs-extra";
+import path4 from "path";
+import pc3 from "picocolors";
+import prompts2 from "prompts";
+
+// src/utils/templates.ts
+var GLOBALS_CSS_TEMPLATE = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  :root {
+    /* Color palette using HSL for easy theming */
+    --primary: 222.2 47.4% 11.2%;
+    --primary-foreground: 210 40% 98%;
+    
+    --secondary: 210 40% 96.1%;
+    --secondary-foreground: 222.2 47.4% 11.2%;
+    
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 210 40% 98%;
+    
+    --muted: 210 40% 96.1%;
+    --muted-foreground: 215.4 16.3% 46.9%;
+    
+    --accent: 210 40% 96.1%;
+    --accent-foreground: 222.2 47.4% 11.2%;
+    
+    --border: 214.3 31.8% 91.4%;
+    --input: 214.3 31.8% 91.4%;
+    --ring: 210 5% 80% / 30%;
+    
+    --background: 0 0% 100%;
+    --foreground: 222.2 47.4% 11.2%;
+    
+    /* Border radius */
+    --radius-sm: 0.375rem;
+    --radius-md: 0.5rem;
+    --radius-lg: 0.75rem;
+    --radius: 0.625rem;
+  }
+
+  .dark {
+    --primary: 210 40% 98%;
+    --primary-foreground: 222.2 47.4% 11.2%;
+    
+    --secondary: 217.2 32.6% 17.5%;
+    --secondary-foreground: 210 40% 98%;
+    
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 210 40% 98%;
+    
+    --muted: 217.2 32.6% 17.5%;
+    --muted-foreground: 215 20.2% 65.1%;
+    
+    --accent: 217.2 32.6% 17.5%;
+    --accent-foreground: 210 40% 98%;
+    
+    --border: 217.2 32.6% 17.5%;
+    --input: 217.2 32.6% 17.5%;
+    --ring: 217.2 32.6% 50% / 30%;
+    
+    --background: 222.2 84% 4.9%;
+    --foreground: 210 40% 98%;
+    --radius: 0.625rem;
+  }
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+`;
+var TAILWIND_CONFIG_TEMPLATE = `import type { Config } from 'tailwindcss'
+
+export default {
+  darkMode: ['class'],
+  content: [
+    './index.html',
+    './src/**/*.{vue,js,ts,jsx,tsx}',
+  ],
+  theme: {
+    extend: {
+      colors: {
+        border: 'hsl(var(--border))',
+        input: 'hsl(var(--input))',
+        ring: 'hsl(var(--ring))',
+        background: 'hsl(var(--background))',
+        foreground: 'hsl(var(--foreground))',
+        primary: {
+          DEFAULT: 'hsl(var(--primary))',
+          foreground: 'hsl(var(--primary-foreground))',
+        },
+        secondary: {
+          DEFAULT: 'hsl(var(--secondary))',
+          foreground: 'hsl(var(--secondary-foreground))',
+        },
+        destructive: {
+          DEFAULT: 'hsl(var(--destructive))',
+          foreground: 'hsl(var(--destructive-foreground))',
+        },
+        muted: {
+          DEFAULT: 'hsl(var(--muted))',
+          foreground: 'hsl(var(--muted-foreground))',
+        },
+        accent: {
+          DEFAULT: 'hsl(var(--accent))',
+          foreground: 'hsl(var(--accent-foreground))',
+        },
+      },
+      borderRadius: {
+        sm: 'var(--radius-sm)',
+        md: 'var(--radius-md)',
+        lg: 'var(--radius-lg)',
+        DEFAULT: 'var(--radius)',
+      },
+    },
+  },
+  plugins: [],
+} satisfies Config
+`;
+function getTemplateConfig(framework, template) {
+  const configs = {
+    "vite-vue": {
+      tailwindConfigPath: "tailwind.config.ts",
+      globalsCssPath: "src/assets/globals.css",
+      componentsPath: "src/components",
+      utilsPath: "src/lib/utils"
+    },
+    nuxt: {
+      tailwindConfigPath: "tailwind.config.ts",
+      globalsCssPath: "assets/css/globals.css",
+      componentsPath: "components",
+      utilsPath: "utils"
+    },
+    next: {
+      tailwindConfigPath: "tailwind.config.ts",
+      globalsCssPath: "src/app/globals.css",
+      componentsPath: "src/components",
+      utilsPath: "src/lib/utils"
+    }
+  };
+  const templateKey = template || `vite-${framework}`;
+  const config = configs[templateKey] || configs["vite-vue"];
+  return {
+    framework,
+    template: templateKey,
+    tailwindConfigPath: config.tailwindConfigPath,
+    globalsCssPath: config.globalsCssPath,
+    componentsPath: config.componentsPath,
+    utilsPath: config.utilsPath
+  };
+}
+
+// src/commands/init.ts
+var SUPPORTED_FRAMEWORKS = ["vue", "react", "svelte", "astro"];
+function detectFramework() {
+  try {
+    const pkg = fs4.readJsonSync(path4.resolve(process.cwd(), "package.json"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps["vue"]) return "vue";
+    if (deps["react"]) return "react";
+    if (deps["svelte"]) return "svelte";
+    if (deps["astro"]) return "astro";
+    return null;
+  } catch {
+    return null;
+  }
+}
+function log2(message, options) {
+  if (!options.silent) {
+    console.log(message);
+  }
+}
+function warn2(message, options) {
+  if (!options.silent) {
+    console.log(pc3.yellow(`\u26A0\uFE0F  ${message}`));
+  }
+}
+function info(message, options) {
+  if (!options.silent) {
+    console.log(pc3.cyan(message));
+  }
+}
+async function init(options = {}) {
+  if (options.preset) {
+    warn2("Preset option is not implemented yet. Coming soon!", options);
+  }
+  if (options.defaults) {
+    warn2("Defaults option is not implemented yet. Coming soon!", options);
+  }
+  if (options.monorepo) {
+    warn2("Monorepo option is not implemented yet. Coming soon!", options);
+  }
+  if (options.reinstall) {
+    warn2("Reinstall option is not implemented yet. Coming soon!", options);
+  }
+  if (options.monorepo === false) {
+  }
+  if (options.reinstall === false) {
+  }
+  const cwd = options.cwd ? path4.resolve(options.cwd) : process.cwd();
+  const validTemplates = ["next", "vite", "start", "react-router", "laravel", "astro"];
+  let template = options.template?.toLowerCase();
+  if (template && !validTemplates.includes(template)) {
+    warn2(`Invalid template "${template}". Using default.`, options);
+    template = void 0;
+  }
+  const configPath = path4.resolve(cwd, "lume.config.json");
+  const configExists = await fs4.pathExists(configPath);
+  if (configExists && !options.force) {
+    if (!options.yes) {
+      const { overwrite } = await prompts2({
+        type: "confirm",
+        name: "overwrite",
+        message: "lume.config.json already exists. Overwrite?",
+        initial: false
+      });
+      if (!overwrite) {
+        log2("Cancelled.", options);
+        return;
+      }
+    }
+  }
+  const detected = detectFramework();
+  let framework;
+  if (detected) {
+    framework = detected;
+    info(`Detected framework: ${detected}`, options);
+  } else if (!options.yes) {
+    const { framework: selectedFramework } = await prompts2({
+      type: "select",
+      name: "framework",
+      message: "Which framework are you using?",
+      choices: SUPPORTED_FRAMEWORKS.map((f) => ({ title: f, value: f }))
+    });
+    framework = selectedFramework;
+  } else {
+    framework = "vue";
+  }
+  if (!framework) {
+    log2(pc3.red("\u274C Framework selection required"), options);
+    process.exit(1);
+  }
+  const templateConfig = getTemplateConfig(framework, template);
+  const useCssVariables = options.cssVariables !== false;
+  const config = {
+    framework,
+    style: useCssVariables ? "css-variables" : "default",
+    template: templateConfig.template,
+    tailwind: {
+      config: templateConfig.tailwindConfigPath,
+      css: templateConfig.globalsCssPath,
+      prefix: ""
+    },
+    aliases: {
+      components: `@/${templateConfig.componentsPath}`,
+      utils: `@/${templateConfig.utilsPath}`
+    }
+  };
+  await fs4.writeJson(configPath, config, { spaces: 2 });
+  log2(pc3.green(`\u2705 Created lume.config.json`), options);
+  let writeFiles = options.yes;
+  if (!options.yes) {
+    const { confirm } = await prompts2({
+      type: "confirm",
+      name: "confirm",
+      message: "Write globals.css and tailwind.config.ts?",
+      initial: true
+    });
+    writeFiles = confirm;
+  }
+  if (writeFiles) {
+    const cssPath = path4.resolve(cwd, templateConfig.globalsCssPath);
+    await fs4.ensureDir(path4.dirname(cssPath));
+    if (await fs4.pathExists(cssPath)) {
+      if (options.force || !options.yes) {
+        const { overwrite } = await prompts2({
+          type: "confirm",
+          name: "overwrite",
+          message: `${templateConfig.globalsCssPath} already exists. Overwrite?`,
+          initial: false
+        });
+        if (overwrite) {
+          await fs4.writeFile(cssPath, GLOBALS_CSS_TEMPLATE);
+          log2(pc3.green(`\u2705 Updated ${templateConfig.globalsCssPath}`), options);
+        }
+      }
+    } else {
+      await fs4.writeFile(cssPath, GLOBALS_CSS_TEMPLATE);
+      log2(pc3.green(`\u2705 Created ${templateConfig.globalsCssPath}`), options);
+    }
+    const tailwindPath = path4.resolve(cwd, templateConfig.tailwindConfigPath);
+    if (await fs4.pathExists(tailwindPath)) {
+      if (options.force || !options.yes) {
+        const { overwrite } = await prompts2({
+          type: "confirm",
+          name: "overwrite",
+          message: `${templateConfig.tailwindConfigPath} already exists. Overwrite?`,
+          initial: false
+        });
+        if (overwrite) {
+          await fs4.writeFile(tailwindPath, TAILWIND_CONFIG_TEMPLATE);
+          log2(pc3.green(`\u2705 Updated ${templateConfig.tailwindConfigPath}`), options);
+        }
+      }
+    } else {
+      await fs4.writeFile(tailwindPath, TAILWIND_CONFIG_TEMPLATE);
+      log2(pc3.green(`\u2705 Created ${templateConfig.tailwindConfigPath}`), options);
+    }
+  }
+  let installDeps = options.yes;
+  if (!options.yes) {
+    const { confirm } = await prompts2({
+      type: "confirm",
+      name: "confirm",
+      message: "Install base dependencies (tailwindcss, autoprefixer, postcss)?",
+      initial: true
+    });
+    installDeps = confirm;
+  }
+  if (installDeps) {
+    log2("", options);
+    const baseDeps = ["tailwindcss", "autoprefixer", "postcss"];
+    installDependencies(baseDeps, { dev: true });
+    log2("", options);
+    const frameworkPkg = framework === "vue" ? "@hemia/lume-vue" : `@hemia/lume-${framework}`;
+    info(`\u{1F4E6} Installing ${frameworkPkg}...`, options);
+    log2(pc3.dim(`   When published, run: npm install ${frameworkPkg}`), options);
+  }
+  log2("", options);
+  log2(pc3.green("\u{1F389} All done! Run the following to add components:"), options);
+  info(`   lume add button`, options);
+  log2("", options);
+}
+
+// src/commands/list.ts
+import fs5 from "fs-extra";
+import path5 from "path";
+import pc4 from "picocolors";
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+function getFrameworkFromConfig2() {
+  try {
+    const config = fs5.readJsonSync(
+      path5.resolve(process.cwd(), "hemia.config.json")
+    );
+    return config.framework ?? "vue";
+  } catch {
+    return "vue";
+  }
+}
+function resolveRegistryPath2(framework) {
+  const registryRoot = path5.dirname(
+    require3.resolve("@hemia/lume-registry/package.json")
+  );
+  return path5.join(registryRoot, "registry", framework);
+}
+async function list(options = {}) {
+  const framework = options.framework ?? getFrameworkFromConfig2();
+  const frameworkRegistry = resolveRegistryPath2(framework);
+  if (!await fs5.pathExists(frameworkRegistry)) {
+    console.log(pc4.red(`\u274C No components found for framework "${framework}"`));
+    process.exit(1);
+  }
+  const entries = await fs5.readdir(frameworkRegistry, { withFileTypes: true });
+  const components = entries.filter((entry) => entry.isDirectory());
+  if (components.length === 0) {
+    console.log(pc4.yellow(`\u26A0\uFE0F  No components available for ${framework}`));
+    return;
+  }
+  console.log(pc4.cyan(`
+\u{1F4E6} Available components for ${framework}:
+`));
+  for (const component of components) {
+    const meta = await readComponentMeta(
+      path5.join(frameworkRegistry, component.name)
+    );
+    if (meta) {
+      const deps = meta.registryDependencies?.length ? pc4.dim(` (requires: ${meta.registryDependencies.join(", ")})`) : "";
+      console.log(`   ${pc4.green("\u25CF")} ${component.name}${deps}`);
+    } else {
+      console.log(`   ${pc4.green("\u25CF")} ${component.name}`);
+    }
+  }
+  console.log();
+  console.log(pc4.dim(`Total: ${components.length} component(s)`));
+  console.log();
+  console.log(pc4.cyan("Usage:"));
+  console.log(pc4.dim(`  hemia add <component-name>`));
+  console.log();
+}
+
+// src/index.ts
+var program = new Command();
+program.name("lume").description("lume CLI \u2014 multi-framework component generator inspired by shadcn/ui").version("0.0.1");
+program.command("init").description("Initialize your project and install dependencies").allowUnknownOption(true).argument("[components...]", "name, url or local path to component").option("-t, --template <template>", "the template to use. (next, vite, start, react-router, laravel, astro)").option("-p, --preset [name]", "use a preset configuration. (name, URL, or preset code)").option("-d, --defaults", "use default configuration. (default: false)").option("-y, --yes", "skip confirmation prompt. (default: true)").option("-f, --force", "force overwrite of existing configuration. (default: false)").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.").option("-s, --silent", "mute output. (default: false)").option("--monorepo", "scaffold a monorepo project.").option("--no-monorepo", "skip the monorepo prompt.").option("--reinstall", "re-install existing UI components.").option("--no-reinstall", "do not re-install existing UI components.").option("--css-variables", "use css variables for theming. (default: true)").option("--no-css-variables", "do not use css variables for theming.").option("-h, --help", "display help for command").action(init);
+program.command("add").description("add a component to your project").allowUnknownOption(true).argument("[components...]", "name, url or local path to component").option("-y, --yes", "skip confirmation prompt. (default: false)").option("-o, --overwrite", "overwrite existing files. (default: false)").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.").option("-a, --all", "add all available components (default: false)").option("-p, --path <path>", "the path to add the component to.").option("-s, --silent", "mute output. (default: false)").option("--dry-run", "preview changes without writing files. (default: false)").option("--diff [path]", "show diff for a file.").option("--view [path]", "show file contents.").option("-h, --help", "display help for command").option("-f, --framework <framework>", "Target framework (vue, react, svelte, astro)").action(add);
+program.command("list").description("List all available components").option("-f, --framework <framework>", "Target framework (vue, react, svelte, astro)").action(list);
+program.parse();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@hemia/lume",
+  "version": "0.0.1",
+  "type": "module",
+  "files": ["dist"],
+  "bin": {
+    "lume": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --watch"
+  },
+  "dependencies": {
+    "@hemia/lume-core": "^0.0.1",
+    "@hemia/lume-registry": "^0.0.1",
+    "commander": "^12.0.0",
+    "fs-extra": "^11.0.0",
+    "picocolors": "^1.0.0",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "@types/fs-extra": "^11.0.0",
+    "@types/prompts": "^2.4.0"
+  }
+}