@hanzo/docs-cli 1.1.1 → 1.2.2

package/dist/index.js

@@ -1,728 +1,644 @@
 #!/usr/bin/env node
-
-// src/index.ts
-import fs6 from "fs/promises";
-import path5 from "path";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { Command } from "commander";
-import picocolors3 from "picocolors";
-
-// src/config.ts
-import fs2 from "fs/promises";
+import picocolors from "picocolors";
+import { z } from "zod";
+import { x } from "tinyexec";
+import { cancel, confirm, group, intro, isCancel, log, multiselect, outro, select, spinner } from "@clack/prompts";
+import { Project } from "ts-morph";
+import { detect } from "package-manager-detector";
 
-// src/utils/fs.ts
-import fs from "fs/promises";
-import path from "path";
+//#region src/utils/fs.ts
 async function exists(pathLike) {
-  try {
-    await fs.access(pathLike);
-    return true;
-  } catch {
-    return false;
-  }
+	try {
+		await fs.access(pathLike);
+		return true;
+	} catch {
+		return false;
+	}
 }
 
-// src/utils/is-src.ts
+//#endregion
+//#region src/utils/is-src.ts
 async function isSrc() {
-  return exists("./src");
+	return exists("./src");
 }
 
-// src/config.ts
-import { z } from "zod";
-function createConfigSchema(isSrc2) {
-  const defaultAliases = {
-    uiDir: "./components/ui",
-    componentsDir: "./components",
-    blockDir: "./components",
-    cssDir: "./styles",
-    libDir: "./lib"
-  };
-  return z.object({
-    aliases: z.object({
-      uiDir: z.string().default(defaultAliases.uiDir),
-      componentsDir: z.string().default(defaultAliases.uiDir),
-      blockDir: z.string().default(defaultAliases.blockDir),
-      cssDir: z.string().default(defaultAliases.componentsDir),
-      libDir: z.string().default(defaultAliases.libDir)
-    }).default(defaultAliases),
-    baseDir: z.string().default(isSrc2 ? "src" : ""),
-    commands: z.object({
-      /**
-       * command to format output code automatically
-       */
-      format: z.string().optional()
-    }).default({})
-  });
+//#endregion
+//#region src/config.ts
+function createConfigSchema(isSrc$1) {
+	const defaultAliases = {
+		uiDir: "./components/ui",
+		componentsDir: "./components",
+		blockDir: "./components",
+		cssDir: "./styles",
+		libDir: "./lib"
+	};
+	return z.object({
+		$schema: z.string().default(isSrc$1 ? "node_modules/@hanzo/docs-cli/dist/schema/src.json" : "node_modules/@hanzo/docs-cli/dist/schema/default.json").optional(),
+		aliases: z.object({
+			uiDir: z.string().default(defaultAliases.uiDir),
+			componentsDir: z.string().default(defaultAliases.uiDir),
+			blockDir: z.string().default(defaultAliases.blockDir),
+			cssDir: z.string().default(defaultAliases.componentsDir),
+			libDir: z.string().default(defaultAliases.libDir)
+		}).default(defaultAliases),
+		baseDir: z.string().default(isSrc$1 ? "src" : ""),
+		uiLibrary: z.enum(["radix-ui", "base-ui"]).default("radix-ui"),
+		commands: z.object({ format: z.string().optional() }).default({})
+	});
 }
 async function createOrLoadConfig(file = "./cli.json") {
-  const inited = await initConfig(file);
-  if (inited) return inited;
-  const content = (await fs2.readFile(file)).toString();
-  const src = await isSrc();
-  const configSchema = createConfigSchema(src);
-  return configSchema.parse(JSON.parse(content));
+	const inited = await initConfig(file);
+	if (inited) return inited;
+	const content = (await fs.readFile(file)).toString();
+	return createConfigSchema(await isSrc()).parse(JSON.parse(content));
 }
-async function initConfig(file = "./cli.json") {
-  if (await fs2.stat(file).then(() => true).catch(() => false)) {
-    return;
-  }
-  const src = await isSrc();
-  const defaultConfig = createConfigSchema(src).parse({});
-  await fs2.writeFile(file, JSON.stringify(defaultConfig, null, 2));
-  return defaultConfig;
+/**
+* Write new config, skip if a config already exists
+*
+* @returns the created config, `undefined` if not created
+*/
+async function initConfig(file = "./cli.json", src) {
+	if (await fs.stat(file).then(() => true).catch(() => false)) return;
+	const defaultConfig = createConfigSchema(src ?? await isSrc()).parse({});
+	await fs.writeFile(file, JSON.stringify(defaultConfig, null, 2));
+	return defaultConfig;
 }
 
-// src/commands/file-tree.ts
-var scanned = ["file", "directory", "link"];
+//#endregion
+//#region src/commands/file-tree.ts
+const scanned = [
+	"file",
+	"directory",
+	"link"
+];
 function treeToMdx(input, noRoot = false) {
-  function toNode(item) {
-    if (item.type === "file" || item.type === "link") {
-      return `<File name=${JSON.stringify(item.name)} />`;
-    }
-    if (item.type === "directory") {
-      if (item.contents.length === 1 && "name" in item.contents[0]) {
-        const child = item.contents[0];
-        return toNode({
-          ...child,
-          name: `${item.name}/${child.name}`
-        });
-      }
-      return `<Folder name=${JSON.stringify(item.name)}>
+	function toNode(item) {
+		if (item.type === "file" || item.type === "link") return `<File name=${JSON.stringify(item.name)} />`;
+		if (item.type === "directory") {
+			if (item.contents.length === 1 && "name" in item.contents[0]) {
+				const child = item.contents[0];
+				return toNode({
+					...child,
+					name: `${item.name}/${child.name}`
+				});
+			}
+			return `<Folder name=${JSON.stringify(item.name)}>
 ${item.contents.map(toNode).filter(Boolean).join("\n")}
 </Folder>`;
-    }
-    return "";
-  }
-  let children = input.filter((v) => scanned.includes(v.type));
-  if (noRoot && children.length === 1 && input[0].type === "directory") {
-    children = input[0].contents;
-  }
-  return `<Files>
+		}
+		return "";
+	}
+	let children = input.filter((v) => scanned.includes(v.type));
+	if (noRoot && children.length === 1 && input[0].type === "directory") children = input[0].contents;
+	return `<Files>
 ${children.map(toNode).filter(Boolean).join("\n")}
 </Files>`;
 }
 function treeToJavaScript(input, noRoot, importName = "@hanzo/docs-ui/components/files") {
-  return `import { File, Files, Folder } from ${JSON.stringify(importName)}
+	return `import { File, Files, Folder } from ${JSON.stringify(importName)}
 
 export default (${treeToMdx(input, noRoot)})`;
 }
 
-// src/utils/file-tree/run-tree.ts
-import { x } from "tinyexec";
+//#endregion
+//#region src/utils/file-tree/run-tree.ts
 async function runTree(args) {
-  const out = await x("tree", [args, "--gitignore", "--prune", "-J"]);
-  try {
-    return JSON.parse(out.stdout);
-  } catch (e) {
-    throw new Error("failed to run `tree` command", {
-      cause: e
-    });
-  }
+	const out = await x("tree", [
+		args,
+		"--gitignore",
+		"--prune",
+		"-J"
+	]);
+	try {
+		return JSON.parse(out.stdout);
+	} catch (e) {
+		throw new Error("failed to run `tree` command", { cause: e });
+	}
 }
 
-// package.json
-var package_default = {
-  name: "@hanzo/docs-cli",
-  version: "1.1.0",
-  description: "The CLI tool for Hanzo Docs",
-  keywords: [
-    "Hanzo",
-    "Docs",
-    "CLI"
-  ],
-  homepage: "https://hanzo.ai/docs",
-  repository: "github:hanzoai/docs",
-  license: "MIT",
-  author: "Fuma Nama",
-  type: "module",
-  exports: {
-    "./build": {
-      import: "./dist/build/index.js",
-      types: "./dist/build/index.d.ts"
-    }
-  },
-  main: "./dist/index.js",
-  bin: {
-    "hanzo-docs": "./dist/index.js"
-  },
-  files: [
-    "dist/*"
-  ],
-  scripts: {
-    build: "tsup",
-    clean: "rimraf dist",
-    dev: "tsup --watch",
-    lint: "eslint .",
-    "types:check": "tsc --noEmit"
-  },
-  dependencies: {
-    "@clack/prompts": "^0.11.0",
-    commander: "^14.0.2",
-    "package-manager-detector": "^1.6.0",
-    picocolors: "^1.1.1",
-    tinyexec: "^1.0.2",
-    "ts-morph": "^27.0.2",
-    zod: "^4.1.13"
-  },
-  devDependencies: {
-    "@types/node": "24.10.2",
-    "eslint-config-custom": "workspace:*",
-    shadcn: "3.6.0",
-    tsconfig: "workspace:*"
-  },
-  publishConfig: {
-    access: "public"
-  }
-};
-
-// src/commands/customise.ts
-import { cancel, group, intro as intro2, log as log4, outro as outro3, select } from "@clack/prompts";
-import picocolors2 from "picocolors";
-
-// src/commands/add.ts
-import {
-  intro,
-  isCancel as isCancel3,
-  log as log3,
-  multiselect,
-  outro as outro2,
-  spinner as spinner2
-} from "@clack/prompts";
-import picocolors from "picocolors";
-
-// src/registry/installer/index.ts
-import path3 from "path";
-import fs4 from "fs/promises";
-import { confirm as confirm2, isCancel as isCancel2, log, outro } from "@clack/prompts";
+//#endregion
+//#region package.json
+var version = "1.2.2";
 
-// src/utils/typescript.ts
-import { Project } from "ts-morph";
+//#endregion
+//#region src/utils/typescript.ts
 function createEmptyProject() {
-  return new Project({
-    compilerOptions: {}
-  });
+	return new Project({ compilerOptions: {} });
 }
 
-// src/constants.ts
-var typescriptExtensions = [".ts", ".tsx", ".js", ".jsx"];
+//#endregion
+//#region src/constants.ts
+const typescriptExtensions = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+];
 
-// src/utils/ast.ts
-import path2 from "path";
+//#endregion
+//#region src/utils/ast.ts
+/**
+* Return the import modifier for `sourceFile` to import `referenceFile`
+*
+* @example
+* ```ts
+* toReferencePath('index.ts', 'dir/hello.ts')
+* // should output './dir/hello'
+* ```
+*/
 function toImportSpecifier(sourceFile, referenceFile) {
-  const extname = path2.extname(referenceFile);
-  const removeExt = typescriptExtensions.includes(extname);
-  const importPath = path2.relative(
-    path2.dirname(sourceFile),
-    removeExt ? referenceFile.substring(0, referenceFile.length - extname.length) : referenceFile
-  ).replaceAll(path2.sep, "/");
-  return importPath.startsWith("../") ? importPath : `./${importPath}`;
+	const extname = path.extname(referenceFile);
+	const removeExt = typescriptExtensions.includes(extname);
+	let importPath = path.relative(path.dirname(sourceFile), removeExt ? referenceFile.substring(0, referenceFile.length - extname.length) : referenceFile).replaceAll(path.sep, "/");
+	if (removeExt && importPath.endsWith("/index")) importPath = importPath.slice(0, -6);
+	return importPath.startsWith("../") ? importPath : `./${importPath}`;
 }
 
-// src/registry/installer/index.ts
-import { x as x3 } from "tinyexec";
+//#endregion
+//#region src/registry/schema.ts
+const namespaces = [
+	"components",
+	"lib",
+	"css",
+	"route",
+	"ui",
+	"block"
+];
+const indexSchema = z.object({
+	name: z.string(),
+	title: z.string().optional(),
+	description: z.string().optional()
+});
+const fileSchema = z.object({
+	type: z.literal(namespaces),
+	path: z.string(),
+	target: z.string().optional(),
+	content: z.string()
+});
+const httpSubComponent = z.object({
+	type: z.literal("http"),
+	baseUrl: z.string(),
+	component: z.string()
+});
+const componentSchema = z.object({
+	name: z.string(),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	files: z.array(fileSchema),
+	dependencies: z.record(z.string(), z.string().or(z.null())),
+	devDependencies: z.record(z.string(), z.string().or(z.null())),
+	subComponents: z.array(z.string().or(httpSubComponent)).default([])
+});
+const registryInfoSchema = z.object({
+	variables: z.record(z.string(), z.object({
+		description: z.string().optional(),
+		default: z.unknown().optional()
+	})).optional(),
+	env: z.record(z.string(), z.unknown()).optional(),
+	indexes: z.array(indexSchema).default([]),
+	registries: z.array(z.string()).optional()
+});
+
+//#endregion
+//#region src/utils/cache.ts
+var AsyncCache = class {
+	constructor() {
+		this.store = /* @__PURE__ */ new Map();
+	}
+	cached(key, fn) {
+		let cached = this.store.get(key);
+		if (cached !== void 0) return cached;
+		cached = fn();
+		this.store.set(key, cached);
+		return cached;
+	}
+};
 
-// src/registry/installer/dep-manager.ts
-import fs3 from "fs/promises";
+//#endregion
+//#region src/registry/client.ts
+const fetchCache = new AsyncCache();
+var HttpRegistryClient = class HttpRegistryClient {
+	constructor(baseUrl, config) {
+		this.baseUrl = baseUrl;
+		this.config = config;
+		this.registryId = baseUrl;
+	}
+	async fetchRegistryInfo(baseUrl = this.baseUrl) {
+		const url = new URL("_registry.json", `${baseUrl}/`);
+		return fetchCache.cached(url.href, async () => {
+			const res = await fetch(url);
+			if (!res.ok) throw new Error(`failed to fetch ${url.href}: ${res.statusText}`);
+			return registryInfoSchema.parse(await res.json());
+		});
+	}
+	async fetchComponent(name) {
+		const url = new URL(`${name}.json`, `${this.baseUrl}/`);
+		return fetchCache.cached(url.href, async () => {
+			const res = await fetch(`${this.baseUrl}/${name}.json`);
+			if (!res.ok) {
+				log.error(`component ${name} not found at ${url.href}`);
+				throw new Error(await res.text());
+			}
+			return componentSchema.parse(await res.json());
+		});
+	}
+	async hasComponent(name) {
+		const url = new URL(`${name}.json`, `${this.baseUrl}/`);
+		return (await fetch(url, { method: "HEAD" })).ok;
+	}
+	createLinkedRegistryClient(name) {
+		return new HttpRegistryClient(`${this.baseUrl}/${name}`, this.config);
+	}
+};
+var LocalRegistryClient = class LocalRegistryClient {
+	constructor(dir, config) {
+		this.dir = dir;
+		this.config = config;
+		this.registryId = dir;
+	}
+	async fetchRegistryInfo(dir = this.dir) {
+		if (this.registryInfo) return this.registryInfo;
+		const filePath = path.join(dir, "_registry.json");
+		const out = await fs.readFile(filePath).then((res) => JSON.parse(res.toString())).catch((e) => {
+			throw new Error(`failed to resolve local file "${filePath}"`, { cause: e });
+		});
+		return this.registryInfo = registryInfoSchema.parse(out);
+	}
+	async fetchComponent(name) {
+		const filePath = path.join(this.dir, `${name}.json`);
+		const out = await fs.readFile(filePath).then((res) => JSON.parse(res.toString())).catch((e) => {
+			log.error(`component ${name} not found at ${filePath}`);
+			throw e;
+		});
+		return componentSchema.parse(out);
+	}
+	async hasComponent(name) {
+		const filePath = path.join(this.dir, `${name}.json`);
+		try {
+			await fs.stat(filePath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	createLinkedRegistryClient(name) {
+		return new LocalRegistryClient(path.join(this.dir, name), this.config);
+	}
+};
 
-// src/utils/get-package-manager.ts
-import { detect } from "package-manager-detector";
+//#endregion
+//#region src/utils/get-package-manager.ts
 async function getPackageManager() {
-  const result = await detect();
-  return result?.name ?? "npm";
+	return (await detect())?.name ?? "npm";
 }
 
-// src/registry/installer/dep-manager.ts
-import { confirm, isCancel, spinner } from "@clack/prompts";
-import { x as x2 } from "tinyexec";
+//#endregion
+//#region src/registry/installer/dep-manager.ts
 var DependencyManager = class {
-  /**
-   * Get dependencies from `package.json`
-   */
-  async getDeps() {
-    if (this.cachedInstalledDeps) return this.cachedInstalledDeps;
-    const dependencies = /* @__PURE__ */ new Map();
-    if (!await exists("package.json")) return dependencies;
-    const content = await fs3.readFile("package.json");
-    const parsed = JSON.parse(content.toString());
-    if ("dependencies" in parsed && typeof parsed.dependencies === "object") {
-      const records = parsed.dependencies;
-      for (const [k, v] of Object.entries(records)) {
-        dependencies.set(k, v);
-      }
-    }
-    if ("devDependencies" in parsed && typeof parsed.devDependencies === "object") {
-      const records = parsed.devDependencies;
-      for (const [k, v] of Object.entries(records)) {
-        dependencies.set(k, v);
-      }
-    }
-    return this.cachedInstalledDeps = dependencies;
-  }
-  async resolveInstallDependencies(deps) {
-    const cachedInstalledDeps = await this.getDeps();
-    return Object.entries(deps).filter(([k]) => !cachedInstalledDeps.has(k)).map(([k, v]) => v === null || v.length === 0 ? k : `${k}@${v}`);
-  }
-  async installDeps(deps, devDeps) {
-    const items = await this.resolveInstallDependencies(deps);
-    const devItems = await this.resolveInstallDependencies(devDeps);
-    if (items.length === 0 && devItems.length === 0) return;
-    const manager = await getPackageManager();
-    const value = await confirm({
-      message: `Do you want to install with ${manager}?
-${[...items, ...devItems].map((v) => `- ${v}`).join("\n")}`
-    });
-    if (isCancel(value) || !value) {
-      return;
-    }
-    const spin = spinner();
-    spin.start("Installing dependencies...");
-    if (items.length > 0) await x2(manager, ["install", ...items]);
-    if (devItems.length > 0) await x2(manager, ["install", ...devItems, "-D"]);
-    spin.stop("Dependencies installed.");
-  }
+	/**
+	* Get dependencies from `package.json`
+	*/
+	async getDeps() {
+		if (this.cachedInstalledDeps) return this.cachedInstalledDeps;
+		const dependencies = /* @__PURE__ */ new Map();
+		if (!await exists("package.json")) return dependencies;
+		const content = await fs.readFile("package.json");
+		const parsed = JSON.parse(content.toString());
+		if ("dependencies" in parsed && typeof parsed.dependencies === "object") {
+			const records = parsed.dependencies;
+			for (const [k, v] of Object.entries(records)) dependencies.set(k, v);
+		}
+		if ("devDependencies" in parsed && typeof parsed.devDependencies === "object") {
+			const records = parsed.devDependencies;
+			for (const [k, v] of Object.entries(records)) dependencies.set(k, v);
+		}
+		return this.cachedInstalledDeps = dependencies;
+	}
+	async resolveInstallDependencies(deps) {
+		const cachedInstalledDeps = await this.getDeps();
+		return Object.entries(deps).filter(([k]) => !cachedInstalledDeps.has(k)).map(([k, v]) => v === null || v.length === 0 ? k : `${k}@${v}`);
+	}
+	async installDeps(deps, devDeps) {
+		const items = await this.resolveInstallDependencies(deps);
+		const devItems = await this.resolveInstallDependencies(devDeps);
+		if (items.length === 0 && devItems.length === 0) return;
+		const manager = await getPackageManager();
+		const value = await confirm({ message: `Do you want to install with ${manager}?
+${[...items, ...devItems].map((v) => `- ${v}`).join("\n")}` });
+		if (isCancel(value) || !value) return;
+		const spin = spinner();
+		spin.start("Installing dependencies...");
+		if (items.length > 0) await x(manager, ["install", ...items]);
+		if (devItems.length > 0) await x(manager, [
+			"install",
+			...devItems,
+			"-D"
+		]);
+		spin.stop("Dependencies installed.");
+	}
 };
 
-// src/utils/cache.ts
-var AsyncCache = class {
-  constructor() {
-    this.store = /* @__PURE__ */ new Map();
-  }
-  cached(key, fn) {
-    let cached = this.store.get(key);
-    if (cached !== void 0) return cached;
-    cached = fn();
-    this.store.set(key, cached);
-    return cached;
-  }
-};
-
-// src/registry/installer/index.ts
+//#endregion
+//#region src/registry/installer/index.ts
 var ComponentInstaller = class {
-  constructor(client) {
-    this.project = createEmptyProject();
-    this.installedFiles = /* @__PURE__ */ new Set();
-    this.downloadCache = new AsyncCache();
-    this.dependencies = {};
-    this.devDependencies = {};
-    this.client = client;
-  }
-  async install(name) {
-    const downloaded = await this.download(name);
-    for (const item of downloaded) {
-      Object.assign(this.dependencies, item.dependencies);
-      Object.assign(this.devDependencies, item.devDependencies);
-    }
-    const fileList = this.buildFileList(downloaded);
-    for (const file of fileList) {
-      const filePath = file.target ?? file.path;
-      if (this.installedFiles.has(filePath)) continue;
-      const outPath = this.resolveOutputPath(file);
-      const output = typescriptExtensions.includes(path3.extname(filePath)) ? await this.transform(outPath, file, fileList) : file.content;
-      const status = await fs4.readFile(outPath).then((res) => {
-        if (res.toString() === output) return "ignore";
-        return "need-update";
-      }).catch(() => "write");
-      this.installedFiles.add(filePath);
-      if (status === "ignore") continue;
-      if (status === "need-update") {
-        const override = await confirm2({
-          message: `Do you want to override ${outPath}?`,
-          initialValue: false
-        });
-        if (isCancel2(override)) {
-          outro("Ended");
-          process.exit(0);
-        }
-        if (!override) continue;
-      }
-      await fs4.mkdir(path3.dirname(outPath), { recursive: true });
-      await fs4.writeFile(outPath, output);
-      log.step(`downloaded ${outPath}`);
-    }
-  }
-  async installDeps() {
-    await new DependencyManager().installDeps(
-      this.dependencies,
-      this.devDependencies
-    );
-  }
-  async onEnd() {
-    const config = this.client.config;
-    if (config.commands.format) {
-      await x3(config.commands.format);
-    }
-  }
-  buildFileList(downloaded) {
-    const map = /* @__PURE__ */ new Map();
-    for (const item of downloaded) {
-      for (const file of item.files) {
-        const filePath = file.target ?? file.path;
-        if (map.has(filePath)) {
-          console.warn(
-            `noticed duplicated output file for ${filePath}, ignoring for now.`
-          );
-          continue;
-        }
-        map.set(filePath, file);
-      }
-    }
-    return Array.from(map.values());
-  }
-  /**
-   * return a list of components, merged with child components.
-   */
-  download(name) {
-    return this.downloadCache.cached(name, async () => {
-      const comp = await this.client.fetchComponent(name);
-      const result = [comp];
-      this.downloadCache.store.set(name, result);
-      const child = await Promise.all(
-        comp.subComponents.map((sub) => this.download(sub))
-      );
-      for (const sub of child) result.push(...sub);
-      return result;
-    });
-  }
-  async transform(filePath, file, fileList) {
-    const sourceFile = this.project.createSourceFile(filePath, file.content, {
-      overwrite: true
-    });
-    const prefix = "@/";
-    for (const specifier of sourceFile.getImportStringLiterals()) {
-      if (specifier.getLiteralValue().startsWith(prefix)) {
-        const lookup = specifier.getLiteralValue().substring(prefix.length);
-        const target = fileList.find((item) => {
-          const filePath2 = item.target ?? item.path;
-          return filePath2 === lookup;
-        });
-        if (target) {
-          specifier.setLiteralValue(
-            toImportSpecifier(filePath, this.resolveOutputPath(target))
-          );
-        } else {
-          console.warn(`cannot find the referenced file of ${specifier}`);
-        }
-      }
-    }
-    for (const statement of sourceFile.getImportDeclarations()) {
-      const info = await this.client.fetchRegistryInfo();
-      const specifier = statement.getModuleSpecifier().getLiteralValue();
-      if (info.switchables && specifier in info.switchables) {
-        const switchable = info.switchables[specifier];
-        statement.setModuleSpecifier(switchable.specifier);
-        for (const member of statement.getNamedImports()) {
-          const name = member.getName();
-          if (name in switchable.members) {
-            member.setName(switchable.members[name]);
-          }
-        }
-      }
-    }
-    return sourceFile.getFullText();
-  }
-  resolveOutputPath(ref) {
-    const config = this.client.config;
-    if (ref.target) {
-      return path3.join(config.baseDir, ref.target);
-    }
-    const base = path3.basename(ref.path);
-    const dir = {
-      components: config.aliases.componentsDir,
-      block: config.aliases.blockDir,
-      ui: config.aliases.uiDir,
-      css: config.aliases.cssDir,
-      lib: config.aliases.libDir,
-      route: "./"
-    }[ref.type];
-    return path3.join(config.baseDir, dir, base);
-  }
+	constructor(rootClient, plugins = []) {
+		this.rootClient = rootClient;
+		this.plugins = plugins;
+		this.project = createEmptyProject();
+		this.installedFiles = /* @__PURE__ */ new Set();
+		this.downloadCache = new AsyncCache();
+		this.dependencies = {};
+		this.devDependencies = {};
+		this.pathToFileCache = new AsyncCache();
+	}
+	async install(name) {
+		let downloaded;
+		const info = await this.rootClient.fetchRegistryInfo();
+		for (const registry of info.registries ?? []) if (name.startsWith(`${registry}/`)) {
+			downloaded = await this.download(name.slice(registry.length + 1), this.rootClient.createLinkedRegistryClient(registry));
+			break;
+		}
+		downloaded ??= await this.download(name, this.rootClient);
+		for (const item of downloaded) {
+			Object.assign(this.dependencies, item.dependencies);
+			Object.assign(this.devDependencies, item.devDependencies);
+		}
+		for (const comp of downloaded) for (const file of comp.files) {
+			const outPath = this.resolveOutputPath(file);
+			if (this.installedFiles.has(outPath)) continue;
+			this.installedFiles.add(outPath);
+			const output = typescriptExtensions.includes(path.extname(outPath)) ? await this.transform(name, file, comp, downloaded) : file.content;
+			const status = await fs.readFile(outPath).then((res) => {
+				if (res.toString() === output) return "ignore";
+				return "need-update";
+			}).catch(() => "write");
+			if (status === "ignore") continue;
+			if (status === "need-update") {
+				const override = await confirm({
+					message: `Do you want to override ${outPath}?`,
+					initialValue: false
+				});
+				if (isCancel(override)) {
+					outro("Ended");
+					process.exit(0);
+				}
+				if (!override) continue;
+			}
+			await fs.mkdir(path.dirname(outPath), { recursive: true });
+			await fs.writeFile(outPath, output);
+			log.step(`downloaded ${outPath}`);
+		}
+	}
+	async installDeps() {
+		await new DependencyManager().installDeps(this.dependencies, this.devDependencies);
+	}
+	async onEnd() {
+		const config = this.rootClient.config;
+		if (config.commands.format) await x(config.commands.format);
+	}
+	/**
+	* return a list of components, merged with child components & variables.
+	*/
+	async download(name, client, contextVariables) {
+		const hash = `${client.registryId} ${name}`;
+		const info = await client.fetchRegistryInfo();
+		const variables = {
+			...contextVariables,
+			...info.env
+		};
+		for (const [k, v] of Object.entries(info.variables ?? {})) variables[k] ??= v.default;
+		return (await this.downloadCache.cached(hash, async () => {
+			const comp = await client.fetchComponent(name);
+			const result = [comp];
+			this.downloadCache.store.set(hash, result);
+			const child = await Promise.all(comp.subComponents.map((sub) => {
+				if (typeof sub === "string") return this.download(sub, client);
+				const baseUrl = this.rootClient instanceof HttpRegistryClient ? new URL(sub.baseUrl, `${this.rootClient.baseUrl}/`).href : sub.baseUrl;
+				return this.download(sub.component, new HttpRegistryClient(baseUrl, client.config), variables);
+			}));
+			for (const sub of child) result.push(...sub);
+			return result;
+		})).map((file) => ({
+			...file,
+			variables
+		}));
+	}
+	async transform(taskId, file, component, allComponents) {
+		const filePath = this.resolveOutputPath(file);
+		const sourceFile = this.project.createSourceFile(filePath, file.content, { overwrite: true });
+		const prefix = "@/";
+		const variables = Object.entries(component.variables ?? {});
+		const pathToFile = await this.pathToFileCache.cached(taskId, () => {
+			const map = /* @__PURE__ */ new Map();
+			for (const comp of allComponents) for (const file$1 of comp.files) map.set(file$1.target ?? file$1.path, file$1);
+			return map;
+		});
+		for (const specifier of sourceFile.getImportStringLiterals()) {
+			for (const [k, v] of variables) specifier.setLiteralValue(specifier.getLiteralValue().replaceAll(`<${k}>`, v));
+			if (specifier.getLiteralValue().startsWith(prefix)) {
+				const lookup = specifier.getLiteralValue().substring(2);
+				const target = pathToFile.get(lookup);
+				if (target) specifier.setLiteralValue(toImportSpecifier(filePath, this.resolveOutputPath(target)));
+				else console.warn(`cannot find the referenced file of ${specifier}`);
+			}
+		}
+		for (const plugin of this.plugins) await plugin.transform?.({
+			file: sourceFile,
+			componentFile: file,
+			component
+		});
+		return sourceFile.getFullText();
+	}
+	resolveOutputPath(file) {
+		const config = this.rootClient.config;
+		const dir = {
+			components: config.aliases.componentsDir,
+			block: config.aliases.blockDir,
+			ui: config.aliases.uiDir,
+			css: config.aliases.cssDir,
+			lib: config.aliases.libDir,
+			route: "./"
+		}[file.type];
+		if (file.target) return path.join(config.baseDir, file.target.replace("<dir>", dir));
+		return path.join(config.baseDir, dir, path.basename(file.path));
+	}
 };
 
-// src/registry/schema.ts
-import { z as z2 } from "zod";
-var namespaces = [
-  "components",
-  "lib",
-  "css",
-  "route",
-  "ui",
-  "block"
-];
-var indexSchema = z2.object({
-  name: z2.string(),
-  title: z2.string().optional(),
-  description: z2.string().optional()
-});
-var fileSchema = z2.object({
-  type: z2.literal(namespaces),
-  path: z2.string(),
-  target: z2.string().optional(),
-  content: z2.string()
-});
-var componentSchema = z2.object({
-  name: z2.string(),
-  title: z2.string().optional(),
-  description: z2.string().optional(),
-  files: z2.array(fileSchema),
-  dependencies: z2.record(z2.string(), z2.string().or(z2.null())),
-  devDependencies: z2.record(z2.string(), z2.string().or(z2.null())),
-  subComponents: z2.array(z2.string()).default([])
-});
-var switchableEntitySchema = z2.object({
-  /**
-   * map specifier string
-   */
-  specifier: z2.string(),
-  /**
-   * map names of exported members
-   */
-  members: z2.record(z2.string(), z2.string())
-});
-var registryInfoSchema = z2.object({
-  switchables: z2.record(z2.string(), switchableEntitySchema).optional(),
-  indexes: z2.array(indexSchema)
-});
-
-// src/registry/client.ts
-import path4 from "path";
-import fs5 from "fs/promises";
-import { log as log2 } from "@clack/prompts";
-function remoteResolver(url) {
-  return async (file) => {
-    const res = await fetch(`${url}/${file}`);
-    if (!res.ok) {
-      throw new Error(`failed to fetch ${url}/${file}: ${res.statusText}`);
-    }
-    return await res.json();
-  };
-}
-function localResolver(dir) {
-  return async (file) => {
-    const filePath = path4.join(dir, file);
-    return await fs5.readFile(filePath).then((res) => JSON.parse(res.toString())).catch((e) => {
-      throw new Error(`failed to resolve local file "${filePath}"`, {
-        cause: e
-      });
-    });
-  };
-}
-var RegistryClient = class {
-  constructor(config, resolver) {
-    this.config = config;
-    this.resolver = resolver;
-  }
-  async fetchRegistryInfo() {
-    this.registryInfo ??= registryInfoSchema.parse(
-      await this.resolver("_registry.json").catch((e) => {
-        log2.error(String(e));
-        process.exit(1);
-      })
-    );
-    return this.registryInfo;
-  }
-  async fetchComponent(name) {
-    return componentSchema.parse(
-      await this.resolver(`${name}.json`).catch((e) => {
-        log2.error(`component ${name} not found:`);
-        log2.error(String(e));
-        process.exit(1);
-      })
-    );
-  }
+//#endregion
+//#region src/commands/shared.ts
+const UIRegistries = {
+	"base-ui": "hanzo-docs/base-ui",
+	"radix-ui": "hanzo-docs/radix-ui"
 };
 
-// src/commands/add.ts
-async function add(input, resolver, config) {
-  const client = new RegistryClient(config, resolver);
-  const installer = new ComponentInstaller(client);
-  let target = input;
-  if (input.length === 0) {
-    const spin = spinner2();
-    spin.start("fetching registry");
-    const info = await client.fetchRegistryInfo();
-    spin.stop(picocolors.bold(picocolors.greenBright("registry fetched")));
-    const value = await multiselect({
-      message: "Select components to install",
-      options: info.indexes.map((item) => ({
-        label: item.title,
-        value: item.name,
-        hint: item.description
-      }))
-    });
-    if (isCancel3(value)) {
-      outro2("Ended");
-      return;
-    }
-    target = value;
-  }
-  await install(target, installer);
+//#endregion
+//#region src/commands/add.ts
+async function add(input, client) {
+	const config = client.config;
+	let target;
+	const installer = new ComponentInstaller(client);
+	const registry = UIRegistries[config.uiLibrary];
+	if (input.length === 0) {
+		const spin = spinner();
+		spin.start("fetching registry");
+		const info = await client.fetchRegistryInfo();
+		const options = [];
+		for (const item of info.indexes) options.push({
+			label: item.title ?? item.name,
+			value: item.name,
+			hint: item.description
+		});
+		const { indexes } = await client.createLinkedRegistryClient(registry).fetchRegistryInfo();
+		for (const item of indexes) options.push({
+			label: item.title ?? item.name,
+			value: `${registry}/${item.name}`,
+			hint: item.description
+		});
+		spin.stop(picocolors.bold(picocolors.greenBright("registry fetched")));
+		const value = await multiselect({
+			message: "Select components to install",
+			options
+		});
+		if (isCancel(value)) {
+			outro("Ended");
+			return;
+		}
+		target = value;
+	} else target = await Promise.all(input.map(async (item) => await client.hasComponent(item) ? item : `${registry}/${item}`));
+	await install(target, installer);
 }
 async function install(target, installer) {
-  for (const name of target) {
-    intro(
-      picocolors.bold(
-        picocolors.inverse(picocolors.cyanBright(`Add Component: ${name}`))
-      )
-    );
-    try {
-      await installer.install(name);
-      outro2(picocolors.bold(picocolors.greenBright(`${name} installed`)));
-    } catch (e) {
-      log3.error(String(e));
-      throw e;
-    }
-  }
-  intro(picocolors.bold("New Dependencies"));
-  await installer.installDeps();
-  await installer.onEnd();
-  outro2(picocolors.bold(picocolors.greenBright("Successful")));
+	for (const name of target) {
+		intro(picocolors.bold(picocolors.inverse(picocolors.cyanBright(`Add Component: ${name}`))));
+		try {
+			await installer.install(name);
+			outro(picocolors.bold(picocolors.greenBright(`${name} installed`)));
+		} catch (e) {
+			log.error(String(e));
+			throw e;
+		}
+	}
+	intro(picocolors.bold("New Dependencies"));
+	await installer.installDeps();
+	await installer.onEnd();
+	outro(picocolors.bold(picocolors.greenBright("Successful")));
 }
 
-// src/commands/customise.ts
-async function customise(resolver, config) {
-  const client = new RegistryClient(config, resolver);
-  intro2(picocolors2.bgBlack(picocolors2.whiteBright("Customise Hanzo Docs UI")));
-  const installer = new ComponentInstaller(client);
-  const result = await group(
-    {
-      target: () => select({
-        message: "What do you want to customise?",
-        options: [
-          {
-            label: "Docs Layout",
-            value: "docs",
-            hint: "main UI of your docs"
-          },
-          {
-            label: "Home Layout",
-            value: "home",
-            hint: "the navbar for your other pages"
-          }
-        ]
-      }),
-      mode: (v) => {
-        if (v.results.target !== "docs") return;
-        return select({
-          message: "Which variant do you want to start from?",
-          options: [
-            {
-              label: "Start from minimal styles",
-              value: "minimal",
-              hint: "for those who want to build their own variant from ground up."
-            },
-            {
-              label: "Start from default layout",
-              value: "full-default",
-              hint: "useful for adjusting small details."
-            },
-            {
-              label: "Start from Notebook layout",
-              value: "full-notebook",
-              hint: "useful for adjusting small details."
-            }
-          ]
-        });
-      }
-    },
-    {
-      onCancel: () => {
-        cancel("Installation Stopped.");
-        process.exit(0);
-      }
-    }
-  );
-  if (result.target === "docs") {
-    const targets = [];
-    if (result.mode === "minimal") {
-      targets.push("layouts/docs-min");
-    } else {
-      targets.push(
-        result.mode === "full-default" ? "layouts/docs" : "layouts/notebook"
-      );
-    }
-    await install(targets, installer);
-    const maps = result.mode === "full-notebook" ? [
-      ["@hanzo/docs-ui/layouts/notebook", "@/components/layout/notebook"],
-      [
-        "@hanzo/docs-ui/layouts/notebook/page",
-        "@/components/layout/notebook/page"
-      ]
-    ] : [
-      ["@hanzo/docs-ui/layouts/docs", "@/components/layout/docs"],
-      ["@hanzo/docs-ui/layouts/docs/page", "@/components/layout/docs/page"]
-    ];
-    printNext(...maps);
-  }
-  if (result.target === "home") {
-    await install(["layouts/home"], installer);
-    printNext(["@hanzo/docs-ui/layouts/home", `@/components/layout/home`]);
-  }
-  outro3(picocolors2.bold("Have fun!"));
+//#endregion
+//#region src/commands/customise.ts
+async function customise(client) {
+	intro(picocolors.bgBlack(picocolors.whiteBright("Customise Fumadocs UI")));
+	const config = client.config;
+	const installer = new ComponentInstaller(client);
+	const result = await group({
+		target: () => select({
+			message: "What do you want to customise?",
+			options: [{
+				label: "Docs Layout",
+				value: "docs",
+				hint: "main UI of your docs"
+			}, {
+				label: "Home Layout",
+				value: "home",
+				hint: "the navbar for your other pages"
+			}]
+		}),
+		mode: (v) => {
+			if (v.results.target !== "docs") return;
+			return select({
+				message: "Which variant do you want to start from?",
+				options: [
+					{
+						label: "Start from minimal styles",
+						value: "minimal",
+						hint: "for those who want to build their own variant from ground up."
+					},
+					{
+						label: "Start from default layout",
+						value: "full-default",
+						hint: "useful for adjusting small details."
+					},
+					{
+						label: "Start from Notebook layout",
+						value: "full-notebook",
+						hint: "useful for adjusting small details."
+					}
+				]
+			});
+		}
+	}, { onCancel: () => {
+		cancel("Installation Stopped.");
+		process.exit(0);
+	} });
+	const registry = UIRegistries[config.uiLibrary];
+	if (result.target === "docs") {
+		const targets = [];
+		if (result.mode === "minimal") targets.push("hanzo-docs/ui/layouts/docs-min");
+		else targets.push(result.mode === "full-default" ? `${registry}/layouts/docs` : `${registry}/layouts/notebook`);
+		await install(targets, installer);
+		printNext(...result.mode === "full-notebook" ? [["@hanzo/docs-ui/layouts/notebook", "@/components/layout/notebook"], ["@hanzo/docs-ui/layouts/notebook/page", "@/components/layout/notebook/page"]] : [["@hanzo/docs-ui/layouts/docs", "@/components/layout/docs"], ["@hanzo/docs-ui/layouts/docs/page", "@/components/layout/docs/page"]]);
+	}
+	if (result.target === "home") {
+		await install([`${registry}/layouts/home`], installer);
+		printNext(["@hanzo/docs-ui/layouts/home", `@/components/layout/home`]);
+	}
+	outro(picocolors.bold("Have fun!"));
 }
 function printNext(...maps) {
-  intro2(picocolors2.bold("What is Next?"));
-  log4.info(
-    [
-      "You can check the installed components in `components`.",
-      picocolors2.dim("---"),
-      "Open your `layout.tsx` files, replace the imports of components:",
-      ...maps.map(
-        ([from, to]) => picocolors2.greenBright(`"${from}" -> "${to}"`)
-      )
-    ].join("\n")
-  );
+	intro(picocolors.bold("What is Next?"));
+	log.info([
+		"You can check the installed components in `components`.",
+		picocolors.dim("---"),
+		"Open your `layout.tsx` files, replace the imports of components:",
+		...maps.map(([from, to]) => picocolors.greenBright(`"${from}" -> "${to}"`))
+	].join("\n"));
 }
 
-// src/index.ts
-var program = new Command().option("--config <string>");
-program.name("hanzo-docs").description("CLI to setup Hanzo Docs, init a config").version(package_default.version).action(async () => {
-  if (await initConfig()) {
-    console.log(picocolors3.green("Initialized a `./cli.json` config file."));
-  } else {
-    console.log(picocolors3.redBright("A config file already exists."));
-  }
+//#endregion
+//#region src/index.ts
+const program = new Command().option("--config <string>");
+program.name("hanzo-docs").description("CLI to setup Hanzo Docs, init a config").version(version).action(async () => {
+	if (await initConfig()) console.log(picocolors.green("Initialized a `./cli.json` config file."));
+	else console.log(picocolors.redBright("A config file already exists."));
 });
 program.command("customise").alias("customize").description("simple way to customise layouts with Hanzo Docs UI").option("--dir <string>", "the root url or directory to resolve registry").action(async (options) => {
-  const resolver = getResolverFromDir(options.dir);
-  await customise(resolver, await createOrLoadConfig(options.config));
+	await customise(createClientFromDir(options.dir, await createOrLoadConfig(options.config)));
 });
-var dirShortcuts = {
-  ":dev": "https://preview.hanzo.ai/registry",
-  ":localhost": "http://localhost:3000/registry"
+const dirShortcuts = {
+	":preview": "https://preview.hanzo.ai/docs/registry",
+	":dev": "http://localhost:3000/registry"
 };
-program.command("add").description("add a new component to your docs").argument("[components...]", "components to download").option("--dir <string>", "the root url or directory to resolve registry").action(
-  async (input, options) => {
-    const resolver = getResolverFromDir(options.dir);
-    await add(input, resolver, await createOrLoadConfig(options.config));
-  }
-);
-program.command("tree").argument(
-  "[json_or_args]",
-  "JSON output of `tree` command or arguments for the `tree` command"
-).argument("[output]", "output path of file").option("--js", "output as JavaScript file").option("--no-root", "remove the root node").option("--import-name <name>", "where to import components (JS only)").action(
-  async (str, output, {
-    js,
-    root,
-    importName
-  }) => {
-    const jsExtensions = [".js", ".tsx", ".jsx"];
-    const noRoot = !root;
-    let nodes;
-    try {
-      nodes = JSON.parse(str ?? "");
-    } catch {
-      nodes = await runTree(str ?? "./");
-    }
-    const out = js || output && jsExtensions.includes(path5.extname(output)) ? treeToJavaScript(nodes, noRoot, importName) : treeToMdx(nodes, noRoot);
-    if (output) {
-      await fs6.mkdir(path5.dirname(output), { recursive: true });
-      await fs6.writeFile(output, out);
-    } else {
-      console.log(out);
-    }
-  }
-);
-function getResolverFromDir(dir = "https://hanzo.ai/registry") {
-  if (dir in dirShortcuts) dir = dirShortcuts[dir];
-  return dir.startsWith("http://") || dir.startsWith("https://") ? remoteResolver(dir) : localResolver(dir);
+program.command("add").description("add a new component to your docs").argument("[components...]", "components to download").option("--dir <string>", "the root url or directory to resolve registry").action(async (input, options) => {
+	await add(input, createClientFromDir(options.dir, await createOrLoadConfig(options.config)));
+});
+program.command("tree").argument("[json_or_args]", "JSON output of `tree` command or arguments for the `tree` command").argument("[output]", "output path of file").option("--js", "output as JavaScript file").option("--no-root", "remove the root node").option("--import-name <name>", "where to import components (JS only)").action(async (str, output, { js, root, importName }) => {
+	const jsExtensions = [
+		".js",
+		".tsx",
+		".jsx"
+	];
+	const noRoot = !root;
+	let nodes;
+	try {
+		nodes = JSON.parse(str ?? "");
+	} catch {
+		nodes = await runTree(str ?? "./");
+	}
+	const out = js || output && jsExtensions.includes(path.extname(output)) ? treeToJavaScript(nodes, noRoot, importName) : treeToMdx(nodes, noRoot);
+	if (output) {
+		await fs.mkdir(path.dirname(output), { recursive: true });
+		await fs.writeFile(output, out);
+	} else console.log(out);
+});
+function createClientFromDir(dir = "https://hanzo.ai/docs/registry", config) {
+	if (dir in dirShortcuts) dir = dirShortcuts[dir];
+	return dir.startsWith("http://") || dir.startsWith("https://") ? new HttpRegistryClient(dir, config) : new LocalRegistryClient(dir, config);
 }
 program.parse();
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.js.map