reborn-ui 0.1.1

package/dist/index.js

@@ -0,0 +1,871 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command4 } from "commander";
+
+// src/commands/add.ts
+import path4 from "path";
+import { Command } from "commander";
+import prompts from "prompts";
+
+// src/utils/fs.ts
+import { createHash } from "crypto";
+import fs from "fs/promises";
+import path from "path";
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function readJsonFile(filePath) {
+  const raw = await fs.readFile(filePath, "utf8");
+  return JSON.parse(raw);
+}
+async function writeJsonFile(filePath, data) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+async function writeTextFile(filePath, content) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf8");
+}
+async function listFilesRecursive(dirPath, opts) {
+  const ignoreDirNames = opts?.ignoreDirNames ?? /* @__PURE__ */ new Set(["node_modules", ".git", ".nuxt", "dist", ".output"]);
+  const out = [];
+  async function walk(current) {
+    const entries = await fs.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const p = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (ignoreDirNames.has(entry.name)) continue;
+        await walk(p);
+      } else if (entry.isFile()) {
+        out.push(p);
+      }
+    }
+  }
+  await walk(dirPath);
+  return out;
+}
+async function copyDirRecursive(params) {
+  const { fromDir, toDir, overwrite } = params;
+  const ignoreFileNames = params.ignoreFileNames ?? /* @__PURE__ */ new Set([".DS_Store"]);
+  const entries = await fs.readdir(fromDir, { withFileTypes: true });
+  await ensureDir(toDir);
+  for (const entry of entries) {
+    if (ignoreFileNames.has(entry.name)) continue;
+    const from = path.join(fromDir, entry.name);
+    const to = path.join(toDir, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirRecursive({ fromDir: from, toDir: to, overwrite, ignoreFileNames });
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!overwrite) {
+      try {
+        await fs.access(to);
+        continue;
+      } catch {
+      }
+    }
+    await ensureDir(path.dirname(to));
+    await fs.copyFile(from, to);
+  }
+}
+function sha1(text) {
+  return createHash("sha1").update(text).digest("hex");
+}
+
+// src/utils/pm.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import { execa } from "execa";
+async function detectPackageManager(cwd) {
+  if (await pathExists(path2.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists(path2.join(cwd, "yarn.lock"))) return "yarn";
+  if (await pathExists(path2.join(cwd, "package-lock.json"))) return "npm";
+  if (await pathExists(path2.join(cwd, "bun.lockb"))) return "bun";
+  return "pnpm";
+}
+async function readPackageJson(cwd) {
+  return await readJsonFile(path2.join(cwd, "package.json"));
+}
+function getMissingDeps(pkg, deps) {
+  const existing = /* @__PURE__ */ new Set([
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.devDependencies ?? {})
+  ]);
+  return deps.filter((d) => !existing.has(d));
+}
+async function installDeps(params) {
+  const { cwd, pm, deps, dev } = params;
+  if (!deps.length) return;
+  const args = [];
+  if (pm === "pnpm") args.push("add");
+  else if (pm === "npm") args.push("install");
+  else if (pm === "yarn") args.push("add");
+  else if (pm === "bun") args.push("add");
+  if (dev) {
+    if (pm === "npm") args.push("--save-dev");
+    else args.push("-D");
+  }
+  args.push(...deps);
+  await execa(pm, args, { cwd, stdio: "inherit" });
+}
+
+// src/utils/registry.ts
+import path3 from "path";
+import fs3 from "fs";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+var DEFAULT_CONFIG_PATH = "components.json";
+function findNearestPackageRoot(from) {
+  let dir = path3.dirname(fileURLToPath(from));
+  while (true) {
+    if (fs3.existsSync(path3.join(dir, "package.json"))) return dir;
+    const parent = path3.dirname(dir);
+    if (parent === dir) return dir;
+    dir = parent;
+  }
+}
+function defaultConfig() {
+  return {
+    schemaVersion: 1,
+    componentsDir: "components",
+    libDir: "lib",
+    composablesDir: "composables",
+    // 默认使用 CLI 包内置的 registry（随 reborn-ui 一起发布）
+    registry: "builtin",
+    // 项目根目录映射别名符号（默认 @）
+    aliasSymbol: "@"
+  };
+}
+async function loadConfig(cwd, configPath = DEFAULT_CONFIG_PATH) {
+  const abs = path3.isAbsolute(configPath) ? configPath : path3.join(cwd, configPath);
+  if (!await pathExists(abs)) return null;
+  return await readJsonFile(abs);
+}
+function resolveRegistryJsonPath(params) {
+  const { cwd, registry } = params;
+  if (!registry || registry === "builtin") {
+    const pkgRoot = findNearestPackageRoot(import.meta.url);
+    return path3.join(pkgRoot, "registry", "registry.json");
+  }
+  const looksLikePath = registry.includes("/") || registry.includes("\\") || registry.endsWith(".json");
+  if (looksLikePath) {
+    const abs = path3.isAbsolute(registry) ? registry : path3.join(cwd, registry);
+    return abs;
+  }
+  const require2 = createRequire(import.meta.url);
+  return require2.resolve(`${registry}/registry/registry.json`);
+}
+async function loadRegistry(params) {
+  const jsonPath = resolveRegistryJsonPath(params);
+  return await readJsonFile(jsonPath);
+}
+async function loadConfigCompat(cwd, configPath) {
+  if (configPath) return await loadConfig(cwd, configPath);
+  const primary = await loadConfig(cwd, DEFAULT_CONFIG_PATH);
+  if (primary) return primary;
+  return await loadConfig(cwd, "shadcn-docs.json");
+}
+
+// src/commands/add.ts
+function rewriteImports(params) {
+  const { content, aliasSymbol } = params;
+  if (!aliasSymbol || aliasSymbol === "@") return content;
+  return content.replaceAll("@/", `${aliasSymbol}/`);
+}
+async function writeComponentFiles(params) {
+  const { cwd, componentsDir, aliasSymbol, component, overwrite } = params;
+  const baseDir = path4.join(cwd, componentsDir, component.name);
+  await ensureDir(baseDir);
+  for (const f of component.files) {
+    const target = path4.join(baseDir, ...f.path.split("/"));
+    if (!overwrite && await pathExists(target)) continue;
+    const nextContent = rewriteImports({ content: f.content, aliasSymbol });
+    await writeTextFile(target, nextContent);
+  }
+  return baseDir;
+}
+function addCommand() {
+  const cmd = new Command("add").description("\u5411\u9879\u76EE\u4E2D\u6DFB\u52A0\u7EC4\u4EF6\u4E0E\u76F8\u5173\u4F9D\u8D56").argument("[components...]", "\u7EC4\u4EF6\u540D\uFF08\u53EF\u591A\u4E2A\uFF09").option("--cwd <path>", "\u76EE\u6807\u9879\u76EE\u76EE\u5F55", process.cwd()).option("--pm <pm>", "\u5305\u7BA1\u7406\u5668\uFF1Apnpm|npm|yarn|bun").option("--yes", "\u8DF3\u8FC7\u4EA4\u4E92", false).option("--overwrite", "\u8986\u76D6\u5DF2\u5B58\u5728\u6587\u4EF6", false).option("--config <path>", "\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9 cwd\uFF09", "components.json").option("--registry <pkgOrPath>", "\u8986\u76D6\u914D\u7F6E\u91CC\u7684 registry").option("--components-dir <path>", "\u8986\u76D6\u914D\u7F6E\u91CC\u7684 componentsDir").option("--lib-dir <path>", "\u8986\u76D6\u914D\u7F6E\u91CC\u7684 libDir").option("--alias-symbol <symbol>", "\u8986\u76D6\u914D\u7F6E\u91CC\u7684 aliasSymbol\uFF08\u9ED8\u8BA4 @\uFF09").action(async (components, opts) => {
+    const cwd = path4.resolve(opts.cwd);
+    const pm = opts.pm ?? await detectPackageManager(cwd);
+    const cfg = await loadConfigCompat(cwd, opts.config) ?? defaultConfig();
+    if (opts.registry) cfg.registry = opts.registry;
+    if (opts.componentsDir) cfg.componentsDir = opts.componentsDir;
+    if (opts.libDir) cfg.libDir = opts.libDir;
+    if (opts.aliasSymbol) cfg.aliasSymbol = opts.aliasSymbol;
+    const registry = await loadRegistry({ cwd, registry: cfg.registry });
+    let targets = components ?? [];
+    if (!targets.length) {
+      if (opts.yes) {
+        throw new Error("\u672A\u6307\u5B9A\u7EC4\u4EF6\u540D\uFF1B\u8BF7\u4F20\u5165\u7EC4\u4EF6\u53C2\u6570\u6216\u53BB\u6389 --yes \u4EE5\u4EA4\u4E92\u9009\u62E9\u3002");
+      }
+      const choices = registry.components.map((c) => ({
+        title: c.name,
+        value: c.name
+      }));
+      const res = await prompts(
+        [
+          {
+            type: "multiselect",
+            name: "selected",
+            message: "\u9009\u62E9\u8981\u6DFB\u52A0\u7684\u7EC4\u4EF6",
+            choices,
+            min: 1
+          }
+        ],
+        {
+          onCancel: () => {
+            throw new Error("\u5DF2\u53D6\u6D88");
+          }
+        }
+      );
+      targets = res.selected ?? [];
+    }
+    const pkg = await readPackageJson(cwd);
+    const allDeps = /* @__PURE__ */ new Set();
+    for (const name of targets) {
+      const c = registry.components.find((x) => x.name === name);
+      if (!c) throw new Error(`registry \u4E2D\u4E0D\u5B58\u5728\u8BE5\u7EC4\u4EF6\uFF1A${name}`);
+      const outDir = await writeComponentFiles({
+        cwd,
+        componentsDir: cfg.componentsDir,
+        aliasSymbol: cfg.aliasSymbol ?? "@",
+        component: c,
+        overwrite: opts.overwrite
+      });
+      console.log(`\u5DF2\u5199\u5165\u7EC4\u4EF6\uFF1A${name} -> ${path4.relative(cwd, outDir)}`);
+      for (const dep of c.dependencies) allDeps.add(dep);
+    }
+    const missing = getMissingDeps(pkg, [...allDeps]);
+    await installDeps({ cwd, pm, deps: missing });
+    console.log(
+      `\u5B8C\u6210\uFF1A\u6DFB\u52A0 ${targets.length} \u4E2A\u7EC4\u4EF6\uFF1B\u8865\u88C5\u4F9D\u8D56 ${missing.length} \u4E2A\uFF08pm=${pm}\uFF09`
+    );
+  });
+  return cmd;
+}
+
+// src/commands/build.ts
+import path5 from "path";
+import fs4 from "fs/promises";
+import fssync from "fs";
+import { Command as Command2 } from "commander";
+
+// src/utils/imports.ts
+var IMPORT_RE = /\bfrom\s+["']([^"']+)["']|\bimport\(\s*["']([^"']+)["']\s*\)|\brequire\(\s*["']([^"']+)["']\s*\)/g;
+function normalizePackageName(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("@/") || specifier.startsWith("~/") || specifier.startsWith("#") || specifier.startsWith("virtual:")) {
+    return null;
+  }
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    if (parts.length >= 2) return `${parts[0]}/${parts[1]}`;
+    return specifier;
+  }
+  return specifier.split("/")[0] ?? null;
+}
+function extractNpmDependenciesFromText(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(IMPORT_RE)) {
+    const spec = match[1] ?? match[2] ?? match[3];
+    if (!spec) continue;
+    const pkg = normalizePackageName(spec);
+    if (!pkg) continue;
+    out.add(pkg);
+  }
+  out.delete("nuxt");
+  out.delete("vue");
+  return [...out].sort();
+}
+
+// src/commands/build.ts
+function isAllowedFile(filePath) {
+  const ext = path5.extname(filePath).toLowerCase();
+  return [
+    ".vue",
+    ".ts",
+    ".js",
+    ".json",
+    ".css",
+    ".md",
+    ".svg"
+  ].includes(ext);
+}
+function findWorkspaceRoot(startDir) {
+  let current = path5.resolve(startDir);
+  for (; ; ) {
+    const marker = path5.join(current, "pnpm-workspace.yaml");
+    if (fssync.existsSync(marker)) return current;
+    const parent = path5.dirname(current);
+    if (parent === current) return startDir;
+    current = parent;
+  }
+}
+function buildCommand() {
+  const cmd = new Command2("build").description("\uFF08\u5185\u90E8\uFF09\u626B\u63CF\u7EC4\u4EF6\u6E90\u7801\u5E76\u751F\u6210 registry JSON").option("--root <path>", "\u4ED3\u5E93\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\u81EA\u52A8\u5411\u4E0A\u67E5\u627E pnpm-workspace.yaml\uFF09").option(
+    "--source <path>",
+    "\u7EC4\u4EF6\u6E90\u7801\u76EE\u5F55\uFF08\u76F8\u5BF9 root\uFF09",
+    "components/content/reborn"
+  ).option(
+    "--out <path>",
+    "\u8F93\u51FA registry.json \u8DEF\u5F84\uFF08\u76F8\u5BF9 root\uFF09",
+    "packages/cli/registry/registry.json"
+  ).option(
+    "--also-out <path>",
+    "\u989D\u5916\u518D\u8F93\u51FA\u4E00\u4EFD registry.json\uFF08\u53EF\u91CD\u590D\u4F20\u53C2\uFF09",
+    (val, acc) => {
+      acc.push(val);
+      return acc;
+    },
+    []
+  ).action(async (opts) => {
+    const rootDir = opts.root ? path5.resolve(opts.root) : findWorkspaceRoot(process.cwd());
+    const sourceDir = path5.join(rootDir, opts.source);
+    const outPath = path5.join(rootDir, opts.out);
+    const alsoOutPaths = (opts.alsoOut ?? []).map(
+      (p) => path5.join(rootDir, p)
+    );
+    const dirents = await fs4.readdir(sourceDir, { withFileTypes: true });
+    const componentDirs = dirents.filter((d) => d.isDirectory()).map((d) => path5.join(sourceDir, d.name)).sort((a, b) => a.localeCompare(b));
+    const components = [];
+    for (const absComponentDir of componentDirs) {
+      const name = path5.basename(absComponentDir);
+      const absFiles = (await listFilesRecursive(absComponentDir)).filter(
+        isAllowedFile
+      );
+      const files = [];
+      const depSet = /* @__PURE__ */ new Set();
+      for (const absFile of absFiles) {
+        const rel = path5.relative(absComponentDir, absFile).split(path5.sep).join("/");
+        const content = await fs4.readFile(absFile, "utf8");
+        files.push({ path: rel, content });
+        const ext = path5.extname(absFile).toLowerCase();
+        if (ext === ".ts" || ext === ".js" || ext === ".vue") {
+          for (const dep of extractNpmDependenciesFromText(content)) {
+            depSet.add(dep);
+          }
+        }
+      }
+      components.push({
+        name,
+        dependencies: [...depSet].sort(),
+        files
+      });
+    }
+    const registry = {
+      schemaVersion: 1,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source: {
+        rootDir: rootDir.split(path5.sep).join("/"),
+        componentsDir: opts.source
+      },
+      components
+    };
+    async function writeOut(targetRegistryPath) {
+      const outComponentsDir = path5.join(
+        path5.dirname(targetRegistryPath),
+        "components"
+      );
+      await writeJsonFile(targetRegistryPath, registry);
+      await fs4.mkdir(outComponentsDir, { recursive: true });
+      for (const c of components) {
+        await writeJsonFile(
+          path5.join(outComponentsDir, `${c.name}.json`),
+          {
+            ...c,
+            fileCount: c.files.length,
+            contentHash: sha1(JSON.stringify(c.files.map((f) => f.content)))
+          }
+        );
+      }
+    }
+    await writeOut(outPath);
+    for (const p of alsoOutPaths) await writeOut(p);
+    console.log(
+      `registry \u5DF2\u751F\u6210\uFF1A${path5.relative(process.cwd(), outPath)}\uFF08${components.length} \u4E2A\u7EC4\u4EF6\uFF09`
+    );
+  });
+  return cmd;
+}
+
+// src/commands/init.ts
+import path7 from "path";
+import fs6 from "fs/promises";
+import { Command as Command3 } from "commander";
+import prompts2 from "prompts";
+
+// src/utils/templates.ts
+import path6 from "path";
+import fs5 from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function findNearestPackageRoot2(from) {
+  let dir = path6.dirname(fileURLToPath2(from));
+  while (true) {
+    if (fs5.existsSync(path6.join(dir, "package.json"))) return dir;
+    const parent = path6.dirname(dir);
+    if (parent === dir) return dir;
+    dir = parent;
+  }
+}
+function getTemplatesRootDir() {
+  const pkgRoot = findNearestPackageRoot2(import.meta.url);
+  return path6.join(pkgRoot, "templates");
+}
+async function copyTemplateSubdir(params) {
+  const templatesRoot = getTemplatesRootDir();
+  const fromDir = path6.join(templatesRoot, params.subdir);
+  if (!await pathExists(fromDir)) return false;
+  const toDir = path6.join(params.cwd, params.targetDir);
+  await copyDirRecursive({ fromDir, toDir, overwrite: params.overwrite });
+  return true;
+}
+
+// src/commands/init.ts
+function looksLikeNuxtProject(cwd) {
+  return Promise.all([
+    pathExists(path7.join(cwd, "nuxt.config.ts")),
+    pathExists(path7.join(cwd, "nuxt.config.js")),
+    pathExists(path7.join(cwd, "nuxt.config.mjs"))
+  ]).then((arr) => arr.some(Boolean));
+}
+function isTailwindConfig(content) {
+  return content.includes("tailwind") || content.includes("content:");
+}
+function makeDefaultTailwindConfig(params) {
+  const { contentGlobs } = params;
+  const globs = contentGlobs.map((g) => `    "${g}",`).join("\n");
+  return `/** @type {import('tailwindcss').Config} */
+export default {
+  darkMode: ['class'],
+  content: [
+${globs}
+  ],
+  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))',
+        },
+        popover: {
+          DEFAULT: 'hsl(var(--popover))',
+          foreground: 'hsl(var(--popover-foreground))',
+        },
+        card: {
+          DEFAULT: 'hsl(var(--card))',
+          foreground: 'hsl(var(--card-foreground))',
+        },
+      },
+      borderRadius: {
+        xl: 'calc(var(--radius) + 4px)',
+        lg: 'var(--radius)',
+        md: 'calc(var(--radius) - 2px)',
+        sm: 'calc(var(--radius) - 4px)',
+      },
+    },
+  },
+  plugins: [],
+};
+`;
+}
+function patchTailwindContentArray(existing, wantedGlobs) {
+  const m = existing.match(/content\s*:\s*\[([\s\S]*?)\]/m);
+  if (!m) return null;
+  const inner = m[1] ?? "";
+  const missing = wantedGlobs.filter((g) => !inner.includes(g));
+  if (!missing.length) return existing;
+  const insertion = missing.map((g) => `    "${g}",`).join("\n");
+  const replaced = existing.replace(
+    /content\s*:\s*\[([\s\S]*?)\]/m,
+    (full) => {
+      return full.replace(/\]\s*$/, `${insertion}
+  ]`);
+    }
+  );
+  return replaced;
+}
+function defaultCssVariables() {
+  return `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 222.2 84% 4.9%;
+
+    --card: 0 0% 100%;
+    --card-foreground: 222.2 84% 4.9%;
+
+    --popover: 0 0% 100%;
+    --popover-foreground: 222.2 84% 4.9%;
+
+    --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%;
+
+    --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%;
+
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 210 40% 98%;
+
+    --border: 214.3 31.8% 91.4%;
+    --input: 214.3 31.8% 91.4%;
+    --ring: 222.2 84% 4.9%;
+
+    --radius: 0.5rem;
+  }
+
+  .dark {
+    --background: 222.2 84% 4.9%;
+    --foreground: 210 40% 98%;
+
+    --card: 222.2 84% 4.9%;
+    --card-foreground: 210 40% 98%;
+
+    --popover: 222.2 84% 4.9%;
+    --popover-foreground: 210 40% 98%;
+
+    --primary: 210 40% 98%;
+    --primary-foreground: 222.2 47.4% 11.2%;
+
+    --secondary: 217.2 32.6% 17.5%;
+    --secondary-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%;
+
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 210 40% 98%;
+
+    --border: 217.2 32.6% 17.5%;
+    --input: 217.2 32.6% 17.5%;
+    --ring: 212.7 26.8% 83.9%;
+  }
+}
+`;
+}
+function cnUtilsTs(params) {
+  void params;
+  return `import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+`;
+}
+async function patchNuxtConfigAddCss(params) {
+  const { cwd, cssPath } = params;
+  const nuxtConfigPath = path7.join(cwd, "nuxt.config.ts");
+  if (!await pathExists(nuxtConfigPath)) return false;
+  const raw = await fs6.readFile(nuxtConfigPath, "utf8");
+  if (raw.includes(cssPath)) return true;
+  if (raw.match(/\bcss\s*:\s*\[/)) {
+    const patched2 = raw.replace(/\bcss\s*:\s*\[/, `css: ["${cssPath}", `);
+    await fs6.writeFile(nuxtConfigPath, patched2, "utf8");
+    return true;
+  }
+  const m = raw.match(/defineNuxtConfig\(\s*\{\s*/);
+  if (!m) return false;
+  const patched = raw.replace(
+    /defineNuxtConfig\(\s*\{\s*/,
+    (s) => `${s}
+  css: ["${cssPath}"],
+`
+  );
+  await fs6.writeFile(nuxtConfigPath, patched, "utf8");
+  return true;
+}
+async function rewriteAliasInDir(params) {
+  const { cwd, targetDir, aliasSymbol } = params;
+  if (!aliasSymbol || aliasSymbol === "@") return;
+  const absDir = path7.join(cwd, targetDir);
+  if (!await pathExists(absDir)) return;
+  const files = await listFilesRecursive(absDir);
+  for (const f of files) {
+    const ext = path7.extname(f).toLowerCase();
+    if (![".ts", ".tsx", ".js", ".jsx", ".vue", ".mjs", ".cjs"].includes(ext)) continue;
+    const raw = await fs6.readFile(f, "utf8");
+    const next = raw.replaceAll("@/", `${aliasSymbol}/`);
+    if (next !== raw) await fs6.writeFile(f, next, "utf8");
+  }
+}
+function initCommand() {
+  const cmd = new Command3("init").description("\u521D\u59CB\u5316\u65B0\u9879\u76EE\uFF1A\u5B89\u88C5\u4F9D\u8D56\u3001\u751F\u6210 cn/utils\u3001\u914D\u7F6E tailwind \u4E0E CSS \u53D8\u91CF\uFF0C\u5E76\u5199\u5165 components.json").option("--cwd <path>", "\u76EE\u6807\u9879\u76EE\u76EE\u5F55", process.cwd()).option("--pm <pm>", "\u5305\u7BA1\u7406\u5668\uFF1Apnpm|npm|yarn|bun").option("--yes", "\u8DF3\u8FC7\u4EA4\u4E92\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u503C", false).option("--overwrite", "\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u6A21\u677F\u6587\u4EF6\uFF08lib/composables\uFF09", false).option(
+    "--config <path>",
+    "\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9 cwd\uFF09",
+    DEFAULT_CONFIG_PATH
+  ).option(
+    "--components-dir <path>",
+    "\u7EC4\u4EF6\u5199\u5165\u76EE\u5F55",
+    defaultConfig().componentsDir
+  ).option(
+    "--lib-dir <path>",
+    "lib \u76EE\u5F55\uFF08cn/utils\uFF09",
+    defaultConfig().libDir
+  ).option(
+    "--composables-dir <path>",
+    "composables \u76EE\u5F55",
+    defaultConfig().composablesDir
+  ).option(
+    "--alias-symbol <symbol>",
+    "\u9879\u76EE\u6839\u76EE\u5F55\u6620\u5C04\u522B\u540D\u7B26\u53F7\uFF08\u9ED8\u8BA4 @\uFF09",
+    defaultConfig().aliasSymbol
+  ).option("--registry <pkgOrPath>", "registry \u6765\u6E90\uFF08\u9ED8\u8BA4 builtin\uFF09", defaultConfig().registry).action(async (opts) => {
+    const cwd = path7.resolve(opts.cwd);
+    console.log(
+      "\u63D0\u793A\uFF1A\u9879\u76EE\u4E2D\u6709\u90E8\u5206\u4F9D\u8D56\u9700\u8981\u4F7F\u7528@/ \u8DEF\u5F84\u8FDB\u884C\u914D\u7F6E\uFF0C\u8BF7\u60A8\u5B89\u88C5\u5230\u9879\u76EE\u4E2D\u914D\u7F6E\u597D\u7684\u8DEF\u5F84\u4E0B\uFF0C\u8BF7\u614E\u91CD\u9009\u62E9\u6587\u4EF6\u4F4D\u7F6E"
+    );
+    const pkgPath = path7.join(cwd, "package.json");
+    if (!await pathExists(pkgPath)) {
+      throw new Error(`\u672A\u627E\u5230 package.json\uFF1A${pkgPath}`);
+    }
+    const pm = opts.pm ?? await detectPackageManager(cwd);
+    const cfg = {
+      schemaVersion: 1,
+      componentsDir: opts.componentsDir,
+      libDir: opts.libDir,
+      composablesDir: opts.composablesDir,
+      aliasSymbol: opts.aliasSymbol,
+      registry: opts.registry
+    };
+    const existing = await loadConfigCompat(cwd);
+    if (existing) {
+      cfg.componentsDir = opts.componentsDir ?? existing.componentsDir ?? cfg.componentsDir;
+      cfg.libDir = opts.libDir ?? existing.libDir ?? cfg.libDir;
+      cfg.composablesDir = opts.composablesDir ?? existing.composablesDir ?? cfg.composablesDir;
+      cfg.aliasSymbol = opts.aliasSymbol ?? existing.aliasSymbol ?? cfg.aliasSymbol;
+      cfg.registry = opts.registry ?? existing.registry ?? cfg.registry;
+    }
+    if (!opts.yes) {
+      const nuxt = await looksLikeNuxtProject(cwd);
+      const res = await prompts2(
+        [
+          {
+            type: "text",
+            name: "componentsDir",
+            message: "\u7EC4\u4EF6\u76EE\u5F55\uFF08componentsDir\uFF09",
+            initial: cfg.componentsDir
+          },
+          {
+            type: "text",
+            name: "libDir",
+            message: "lib \u76EE\u5F55\uFF08libDir\uFF0C\u7528\u4E8E cn/utils\uFF09",
+            initial: cfg.libDir
+          },
+          {
+            type: "text",
+            name: "composablesDir",
+            message: "composables \u76EE\u5F55\uFF08composablesDir\uFF09",
+            initial: cfg.composablesDir
+          },
+          {
+            type: "text",
+            name: "aliasSymbol",
+            message: "\u57FA\u4E8E\u9879\u76EE\u6839\u76EE\u5F55\u7684\u201C\u6620\u5C04\u201D\u7684\u7B26\u53F7\u662F\uFF1F\uFF08aliasSymbol\uFF09",
+            initial: cfg.aliasSymbol ?? "@"
+          },
+          {
+            type: "text",
+            name: "registry",
+            message: "registry\uFF08\u5305\u540D\u6216\u8DEF\u5F84\uFF09",
+            initial: cfg.registry
+          },
+          {
+            type: "confirm",
+            name: "installBaseDeps",
+            message: `\u5B89\u88C5\u57FA\u7840\u4F9D\u8D56\uFF08clsx\u3001tailwind-merge\u3001tailwindcss \u7B49\uFF09\uFF1F`,
+            initial: true
+          },
+          {
+            type: nuxt ? "confirm" : null,
+            name: "installDocs",
+            message: `\u68C0\u6D4B\u5230 Nuxt\uFF1A\u82E5\u7F3A\u5931\u5219\u5B89\u88C5 shadcn-docs-nuxt\uFF1F`,
+            initial: true
+          }
+        ],
+        {
+          onCancel: () => {
+            throw new Error("\u5DF2\u53D6\u6D88");
+          }
+        }
+      );
+      cfg.componentsDir = res.componentsDir ?? cfg.componentsDir;
+      cfg.libDir = res.libDir ?? cfg.libDir;
+      cfg.composablesDir = res.composablesDir ?? cfg.composablesDir;
+      cfg.aliasSymbol = res.aliasSymbol ?? cfg.aliasSymbol;
+      cfg.registry = res.registry ?? cfg.registry;
+      const cfgPath2 = path7.join(cwd, opts.config);
+      await writeJsonFile(cfgPath2, cfg);
+      const pkg2 = await readPackageJson(cwd);
+      const wantDeps2 = [];
+      if (res.installBaseDeps)
+        wantDeps2.push("clsx", "tailwind-merge", "tailwindcss", "postcss", "autoprefixer");
+      if (res.installDocs) wantDeps2.push("shadcn-docs-nuxt");
+      const missing2 = getMissingDeps(pkg2, wantDeps2);
+      await installDeps({ cwd, pm, deps: missing2 });
+      await copyTemplateSubdir({
+        subdir: "lib",
+        cwd,
+        targetDir: cfg.libDir,
+        overwrite: opts.overwrite
+      });
+      await copyTemplateSubdir({
+        subdir: "composables",
+        cwd,
+        targetDir: cfg.composablesDir,
+        overwrite: opts.overwrite
+      });
+      await rewriteAliasInDir({ cwd, targetDir: cfg.libDir, aliasSymbol: cfg.aliasSymbol ?? "@" });
+      await rewriteAliasInDir({
+        cwd,
+        targetDir: cfg.composablesDir,
+        aliasSymbol: cfg.aliasSymbol ?? "@"
+      });
+      const libUtilsPath2 = path7.join(cwd, cfg.libDir, "utils.ts");
+      if (!await pathExists(libUtilsPath2)) await writeTextFile(libUtilsPath2, cnUtilsTs({}));
+      const cssRel2 = "assets/css/reborn-ui.css";
+      const cssAbs2 = path7.join(cwd, cssRel2);
+      if (!await pathExists(cssAbs2)) {
+        await writeTextFile(cssAbs2, defaultCssVariables());
+      }
+      const contentGlobs2 = [
+        "./components/**/*.{vue,js,ts}",
+        "./layouts/**/*.{vue,js,ts}",
+        "./pages/**/*.{vue,js,ts}",
+        "./plugins/**/*.{js,ts}",
+        "./app.vue",
+        "./error.vue",
+        "./content/**/*.{md,yml,yaml,json}",
+        `./${cfg.componentsDir}/**/*.{vue,js,ts}`,
+        `./${cfg.composablesDir}/**/*.{js,ts}`
+      ];
+      const twPath2 = path7.join(cwd, "tailwind.config.js");
+      if (await pathExists(twPath2)) {
+        const rawTw = await fs6.readFile(twPath2, "utf8");
+        if (isTailwindConfig(rawTw)) {
+          const patched = patchTailwindContentArray(rawTw, contentGlobs2);
+          if (patched && patched !== rawTw) {
+            await fs6.writeFile(twPath2, patched, "utf8");
+          }
+        }
+      } else {
+        await writeTextFile(
+          twPath2,
+          makeDefaultTailwindConfig({ contentGlobs: contentGlobs2 })
+        );
+      }
+      await patchNuxtConfigAddCss({ cwd, cssPath: `~/${cssRel2}` });
+      console.log(
+        `\u5DF2\u5199\u5165\u914D\u7F6E\uFF1A${path7.relative(process.cwd(), cfgPath2)}\uFF1B\u5E76\u751F\u6210 cn/utils\u3001tailwind \u914D\u7F6E\u4E0E CSS \u53D8\u91CF\uFF08pm=${pm}\uFF09`
+      );
+      return;
+    }
+    const cfgPath = path7.join(cwd, opts.config);
+    await ensureDir(path7.dirname(cfgPath));
+    await fs6.writeFile(cfgPath, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+    const pkg = await readPackageJson(cwd);
+    const wantDeps = ["clsx", "tailwind-merge", "tailwindcss", "postcss", "autoprefixer"];
+    if (await looksLikeNuxtProject(cwd)) wantDeps.push("shadcn-docs-nuxt");
+    const missing = getMissingDeps(pkg, wantDeps);
+    await installDeps({ cwd, pm, deps: missing });
+    await copyTemplateSubdir({
+      subdir: "lib",
+      cwd,
+      targetDir: cfg.libDir,
+      overwrite: opts.overwrite
+    });
+    await copyTemplateSubdir({
+      subdir: "composables",
+      cwd,
+      targetDir: cfg.composablesDir,
+      overwrite: opts.overwrite
+    });
+    await rewriteAliasInDir({ cwd, targetDir: cfg.libDir, aliasSymbol: cfg.aliasSymbol ?? "@" });
+    await rewriteAliasInDir({
+      cwd,
+      targetDir: cfg.composablesDir,
+      aliasSymbol: cfg.aliasSymbol ?? "@"
+    });
+    const libUtilsPath = path7.join(cwd, cfg.libDir, "utils.ts");
+    if (!await pathExists(libUtilsPath)) await writeTextFile(libUtilsPath, cnUtilsTs({}));
+    const cssRel = "assets/css/reborn-ui.css";
+    const cssAbs = path7.join(cwd, cssRel);
+    if (!await pathExists(cssAbs)) {
+      await writeTextFile(cssAbs, defaultCssVariables());
+    }
+    const contentGlobs = [
+      "./components/**/*.{vue,js,ts}",
+      "./layouts/**/*.{vue,js,ts}",
+      "./pages/**/*.{vue,js,ts}",
+      "./plugins/**/*.{js,ts}",
+      "./app.vue",
+      "./error.vue",
+      "./content/**/*.{md,yml,yaml,json}",
+      `./${cfg.componentsDir}/**/*.{vue,js,ts}`,
+      `./${cfg.composablesDir}/**/*.{js,ts}`
+    ];
+    const twPath = path7.join(cwd, "tailwind.config.js");
+    if (await pathExists(twPath)) {
+      const rawTw = await fs6.readFile(twPath, "utf8");
+      const patched = patchTailwindContentArray(rawTw, contentGlobs);
+      if (patched && patched !== rawTw) await fs6.writeFile(twPath, patched, "utf8");
+    } else {
+      await writeTextFile(twPath, makeDefaultTailwindConfig({ contentGlobs }));
+    }
+    await patchNuxtConfigAddCss({ cwd, cssPath: `~/${cssRel}` });
+    console.log(
+      `\u5DF2\u521D\u59CB\u5316\uFF1A${path7.relative(process.cwd(), cfgPath)}\uFF1B\u5E76\u751F\u6210 cn/utils\u3001tailwind \u914D\u7F6E\u4E0E CSS \u53D8\u91CF\uFF08pm=${pm}\uFF09`
+    );
+  });
+  return cmd;
+}
+
+// src/index.ts
+var program = new Command4().name("reborn-ui").description("Reborn UI - \u7EC4\u4EF6\u5B89\u88C5\u4E0E registry \u8F85\u52A9 CLI").version("0.1.0");
+program.addCommand(initCommand());
+program.addCommand(addCommand());
+program.addCommand(buildCommand());
+await program.parseAsync(process.argv);
+//# sourceMappingURL=index.js.map