@hanzo/docs-cli 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Fuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/build/index.d.ts

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+import { Project, SourceFile } from 'ts-morph';
+import { Registry as Registry$1 } from 'shadcn/schema';
+
+type NamespaceType = (typeof namespaces)[number];
+type CompiledComponent = z.input<typeof componentSchema>;
+declare const namespaces: readonly ["components", "lib", "css", "route", "ui", "block"];
+declare const indexSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const componentSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    files: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"components" | "lib" | "css" | "route" | "ui" | "block">;
+        path: z.ZodString;
+        target: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    dependencies: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    devDependencies: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    subComponents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+
+type OnResolve = (reference: SourceReference) => Reference;
+interface CompiledRegistry {
+    name: string;
+    index: z.input<typeof indexSchema>[];
+    components: CompiledComponent[];
+    switchables?: Record<string, Switchable>;
+}
+interface ComponentFile {
+    type: NamespaceType;
+    path: string;
+    target?: string;
+}
+interface Switchable {
+    specifier: string;
+    members: Record<string, string>;
+}
+interface Component {
+    name: string;
+    title?: string;
+    description?: string;
+    files: ComponentFile[];
+    /**
+     * Don't list the component in registry index file
+     */
+    unlisted?: boolean;
+    /**
+     * Map imported file paths, inherit from registry if not defined.
+     */
+    onResolve?: OnResolve;
+}
+interface PackageJson {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}
+interface Registry {
+    name: string;
+    packageJson: string | PackageJson;
+    tsconfigPath: string;
+    components: Component[];
+    switchables?: Record<string, Switchable>;
+    /**
+     * The directory of registry, used to resolve relative paths
+     */
+    dir: string;
+    /**
+     * Map import paths of components
+     */
+    onResolve?: OnResolve;
+    /**
+     * When a referenced file is not found in component files, this function is called.
+     * @returns file, or `false` to mark as external.
+     */
+    onUnknownFile?: (absolutePath: string) => ComponentFile | false | undefined;
+    dependencies?: Record<string, string | null>;
+    devDependencies?: Record<string, string | null>;
+}
+declare class RegistryCompiler {
+    readonly raw: Registry;
+    readonly project: Project;
+    resolver: RegistryResolver;
+    constructor(registry: Registry);
+    private readPackageJson;
+    createSourceFile(file: string): Promise<SourceFile>;
+    compile(): Promise<CompiledRegistry>;
+}
+declare class RegistryResolver {
+    private readonly compiler;
+    private readonly deps;
+    private readonly devDeps;
+    private readonly fileToComponent;
+    constructor(compiler: RegistryCompiler, packageJson?: PackageJson);
+    getDepFromSpecifier(specifier: string): string;
+    getDepInfo(name: string): {
+        type: 'runtime' | 'dev';
+        name: string;
+        version: string | null;
+    } | undefined;
+    getComponentByName(name: string): Component | undefined;
+    getSubComponent(file: string): {
+        component: Component;
+        file: ComponentFile;
+    } | undefined;
+}
+type SourceReference = {
+    type: 'file';
+    /**
+     * Absolute path
+     */
+    file: string;
+} | {
+    type: 'dependency';
+    dep: string;
+    specifier: string;
+} | {
+    type: 'sub-component';
+    resolved: {
+        type: 'local';
+        component: Component;
+        file: ComponentFile;
+    } | {
+        type: 'remote';
+        component: Component;
+        file: ComponentFile;
+        registryName: string;
+    };
+};
+type Reference = SourceReference | {
+    type: 'custom';
+    specifier: string;
+};
+declare class ComponentCompiler {
+    private readonly compiler;
+    private readonly component;
+    private readonly processedFiles;
+    private readonly registry;
+    private readonly subComponents;
+    private readonly devDependencies;
+    private readonly dependencies;
+    constructor(compiler: RegistryCompiler, component: Component);
+    private toImportPath;
+    build(): Promise<CompiledComponent>;
+    private buildFileAndDeps;
+    private resolveImport;
+    private buildFile;
+}
+
+declare function toShadcnRegistry(out: CompiledRegistry, baseUrl: string): {
+    registry: Registry$1;
+    index: Registry$1;
+};
+
+declare function combineRegistry(...items: CompiledRegistry[]): CompiledRegistry;
+declare function writeShadcnRegistry(out: CompiledRegistry, options: {
+    dir: string;
+    /**
+     * Remove previous outputs
+     *
+     * @defaultValue false
+     */
+    cleanDir?: boolean;
+    baseUrl: string;
+}): Promise<void>;
+declare function writeFumadocsRegistry(out: CompiledRegistry, options: {
+    dir: string;
+    /**
+     * Remove previous outputs
+     *
+     * @defaultValue false
+     */
+    cleanDir?: boolean;
+    log?: boolean;
+}): Promise<void>;
+
+export { type CompiledRegistry, type Component, ComponentCompiler, type ComponentFile, type OnResolve, type PackageJson, type Reference, type Registry, RegistryCompiler, type SourceReference, type Switchable, combineRegistry, toShadcnRegistry, writeFumadocsRegistry, writeShadcnRegistry };

package/dist/build/index.js

@@ -0,0 +1,423 @@
+// src/build/index.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import picocolors from "picocolors";
+
+// src/build/shadcn.ts
+function mapDeps(deps) {
+  return Object.entries(deps).map(([k, v]) => {
+    if (v) return `${k}@${v}`;
+    return k;
+  });
+}
+function escapeName(name) {
+  return name;
+}
+function toShadcnRegistry(out, baseUrl) {
+  const registry = {
+    homepage: baseUrl,
+    name: out.name,
+    items: out.components.map((comp) => componentToShadcn(comp, baseUrl))
+  };
+  return {
+    registry,
+    index: {
+      ...registry,
+      items: out.components.map(
+        (comp) => componentToShadcn(comp, baseUrl, true)
+      )
+    }
+  };
+}
+function componentToShadcn(comp, baseUrl, noFile = false) {
+  const FileType = {
+    components: "registry:component",
+    lib: "registry:lib",
+    css: "registry:style",
+    route: "registry:page",
+    ui: "registry:ui",
+    block: "registry:block"
+  };
+  function onFile(file) {
+    return {
+      type: FileType[file.type],
+      content: file.content,
+      path: file.path,
+      target: file.target
+    };
+  }
+  return {
+    extends: "none",
+    type: "registry:block",
+    name: escapeName(comp.name),
+    title: comp.title ?? comp.name,
+    description: comp.description,
+    dependencies: mapDeps(comp.dependencies),
+    devDependencies: mapDeps(comp.devDependencies),
+    registryDependencies: comp.subComponents?.map((comp2) => {
+      if (comp2.startsWith("https://") || comp2.startsWith("http://"))
+        return comp2;
+      return new URL(`/r/${escapeName(comp2)}.json`, baseUrl).toString();
+    }),
+    files: noFile ? [] : comp.files.map(onFile)
+  };
+}
+
+// src/build/validate.ts
+function validateOutput(registry) {
+  const validatedComps = /* @__PURE__ */ new Set();
+  const fileToComps = /* @__PURE__ */ new Map();
+  function validateComponent(comp) {
+    if (validatedComps.has(comp.name)) return;
+    validatedComps.add(comp.name);
+    for (const file of comp.files) {
+      const parents = fileToComps.get(file.path);
+      if (parents) {
+        parents.add(comp.name);
+      } else {
+        fileToComps.set(file.path, /* @__PURE__ */ new Set([comp.name]));
+      }
+    }
+    for (const name of comp.subComponents ?? []) {
+      const subComp = registry.components.find((item) => item.name === name);
+      if (!subComp) {
+        console.warn(`skipped component ${name}: not found`);
+        continue;
+      }
+      validateComponent(subComp);
+    }
+    for (const file of comp.files) {
+      const parents = fileToComps.get(file.path);
+      if (!parents || parents.size <= 1) continue;
+      throw new Error(
+        `Duplicated file in same component ${Array.from(parents).join(", ")}: ${file.path}`
+      );
+    }
+  }
+  for (const comp of registry.components) {
+    fileToComps.clear();
+    validateComponent(comp);
+  }
+}
+
+// src/build/compiler.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { Project, ts } from "ts-morph";
+var RegistryCompiler = class {
+  constructor(registry) {
+    this.raw = registry;
+    this.project = new Project({
+      tsConfigFilePath: path.join(registry.dir, registry.tsconfigPath)
+    });
+  }
+  async readPackageJson() {
+    if (typeof this.raw.packageJson !== "string") return this.raw.packageJson;
+    return fs.readFile(path.join(this.raw.dir, this.raw.packageJson)).then((res) => JSON.parse(res.toString())).catch(() => void 0);
+  }
+  async createSourceFile(file) {
+    const content = await fs.readFile(file);
+    return this.project.createSourceFile(file, content.toString(), {
+      overwrite: true
+    });
+  }
+  async compile() {
+    const registry = this.raw;
+    this.resolver = new RegistryResolver(this, await this.readPackageJson());
+    const output = {
+      name: registry.name,
+      index: [],
+      components: [],
+      switchables: registry.switchables
+    };
+    const builtComps = await Promise.all(
+      registry.components.map(async (component) => {
+        const compiler = new ComponentCompiler(this, component);
+        return [component, await compiler.build()];
+      })
+    );
+    for (const [input, comp] of builtComps) {
+      if (!input.unlisted) {
+        output.index.push({
+          name: input.name,
+          title: input.title,
+          description: input.description
+        });
+      }
+      output.components.push(comp);
+    }
+    return output;
+  }
+};
+var RegistryResolver = class {
+  constructor(compiler, packageJson = {}) {
+    this.compiler = compiler;
+    this.fileToComponent = /* @__PURE__ */ new Map();
+    const registry = compiler.raw;
+    for (const comp of registry.components) {
+      for (const file of comp.files) {
+        if (this.fileToComponent.has(file.path))
+          console.warn(
+            `the same file ${file.path} exists in multiple component, you should make the shared file a separate component.`
+          );
+        this.fileToComponent.set(file.path, [comp, file]);
+      }
+    }
+    this.deps = {
+      ...packageJson?.dependencies,
+      ...registry.dependencies
+    };
+    this.devDeps = {
+      ...packageJson?.devDependencies,
+      ...registry.devDependencies
+    };
+  }
+  getDepFromSpecifier(specifier) {
+    return specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+  }
+  getDepInfo(name) {
+    if (name in this.deps)
+      return {
+        name,
+        type: "runtime",
+        version: this.deps[name]
+      };
+    if (name in this.devDeps)
+      return {
+        name,
+        type: "dev",
+        version: this.devDeps[name]
+      };
+    console.warn(`dep info for ${name} cannot be found`);
+  }
+  getComponentByName(name) {
+    return this.compiler.raw.components.find((comp) => comp.name === name);
+  }
+  getSubComponent(file) {
+    const relativeFile = path.relative(this.compiler.raw.dir, file);
+    const comp = this.fileToComponent.get(relativeFile);
+    if (!comp) return;
+    return {
+      component: comp[0],
+      file: comp[1]
+    };
+  }
+};
+var ComponentCompiler = class {
+  constructor(compiler, component) {
+    this.compiler = compiler;
+    this.component = component;
+    this.processedFiles = /* @__PURE__ */ new Set();
+    this.subComponents = /* @__PURE__ */ new Set();
+    this.devDependencies = /* @__PURE__ */ new Map();
+    this.dependencies = /* @__PURE__ */ new Map();
+    this.registry = compiler.raw;
+  }
+  // see https://github.com/shadcn-ui/ui/blob/396275e46a58333caa1fa0a991bd9bc5237d2ee3/packages/shadcn/src/utils/updaters/update-files.ts#L585
+  // to hit the fast-path step, we need to import `target` path first because it's detected from `fileSet`, a set of output file paths
+  toImportPath(file) {
+    let filePath = file.target ?? file.path;
+    if (filePath.startsWith("./")) filePath = filePath.slice(2);
+    return `@/${filePath.replaceAll(path.sep, "/")}`;
+  }
+  async build() {
+    return {
+      name: this.component.name,
+      title: this.component.title,
+      description: this.component.description,
+      files: (await Promise.all(
+        this.component.files.map((file) => this.buildFileAndDeps(file))
+      )).flat(),
+      subComponents: Array.from(this.subComponents),
+      dependencies: Object.fromEntries(this.dependencies),
+      devDependencies: Object.fromEntries(this.devDependencies)
+    };
+  }
+  async buildFileAndDeps(file) {
+    if (this.processedFiles.has(file.path)) return [];
+    this.processedFiles.add(file.path);
+    const resolver = this.compiler.resolver;
+    const queue = [];
+    const result = await this.buildFile(file, (reference) => {
+      if (reference.type === "custom") return reference.specifier;
+      if (reference.type === "file") {
+        const refFile = this.registry.onUnknownFile?.(reference.file);
+        if (refFile) {
+          queue.push(refFile);
+          return this.toImportPath(refFile);
+        }
+        if (refFile === false) return;
+        throw new Error(
+          `Unknown file ${reference.file} referenced by ${file.path}`
+        );
+      }
+      if (reference.type === "sub-component") {
+        const resolved = reference.resolved;
+        if (resolved.component.name !== this.component.name) {
+          this.subComponents.add(resolved.component.name);
+        }
+        return this.toImportPath(resolved.file);
+      }
+      const dep = resolver.getDepInfo(reference.dep);
+      if (dep) {
+        const map = dep.type === "dev" ? this.devDependencies : this.dependencies;
+        map.set(dep.name, dep.version);
+      }
+      return reference.specifier;
+    });
+    return [
+      result,
+      ...(await Promise.all(queue.map((file2) => this.buildFileAndDeps(file2)))).flat()
+    ];
+  }
+  resolveImport(sourceFilePath, specifier, specified) {
+    let filePath;
+    if (specified) {
+      filePath = specified.getFilePath();
+    } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
+      filePath = path.join(path.dirname(sourceFilePath), specifier);
+    } else {
+      if (!specifier.startsWith("node:"))
+        console.warn(`Unknown specifier ${specifier}, skipping for now`);
+      return;
+    }
+    const resolver = this.compiler.resolver;
+    if (path.relative(this.registry.dir, filePath).startsWith("../")) {
+      return {
+        type: "dependency",
+        dep: resolver.getDepFromSpecifier(specifier),
+        specifier
+      };
+    }
+    const sub = resolver.getSubComponent(filePath);
+    if (sub) {
+      return {
+        type: "sub-component",
+        resolved: {
+          type: "local",
+          component: sub.component,
+          file: sub.file
+        }
+      };
+    }
+    return {
+      type: "file",
+      file: filePath
+    };
+  }
+  async buildFile(file, writeReference) {
+    const sourceFilePath = path.join(this.registry.dir, file.path);
+    const process2 = (specifier, specifiedFile) => {
+      const onResolve = this.component.onResolve ?? this.registry.onResolve;
+      let resolved = this.resolveImport(
+        sourceFilePath,
+        specifier.getLiteralValue(),
+        specifiedFile
+      );
+      if (!resolved) return;
+      if (onResolve) resolved = onResolve(resolved);
+      const out = writeReference(resolved);
+      if (out) specifier.setLiteralValue(out);
+    };
+    const sourceFile = await this.compiler.createSourceFile(sourceFilePath);
+    for (const item of sourceFile.getImportDeclarations()) {
+      process2(item.getModuleSpecifier(), item.getModuleSpecifierSourceFile());
+    }
+    for (const item of sourceFile.getExportDeclarations()) {
+      const specifier = item.getModuleSpecifier();
+      if (!specifier) continue;
+      process2(specifier, item.getModuleSpecifierSourceFile());
+    }
+    const calls = sourceFile.getDescendantsOfKind(ts.SyntaxKind.CallExpression);
+    for (const expression of calls) {
+      if (expression.getExpression().isKind(ts.SyntaxKind.ImportKeyword) && expression.getArguments().length === 1) {
+        const argument = expression.getArguments()[0];
+        if (!argument.isKind(ts.SyntaxKind.StringLiteral)) continue;
+        process2(
+          argument,
+          argument.getSymbol()?.getDeclarations()[0].getSourceFile()
+        );
+      }
+    }
+    return {
+      content: sourceFile.getFullText(),
+      type: file.type,
+      path: file.path,
+      target: file.target
+    };
+  }
+};
+
+// src/build/index.ts
+function combineRegistry(...items) {
+  const out = {
+    index: [],
+    components: [],
+    name: items[0].name
+  };
+  for (const item of items) {
+    out.components.push(...item.components);
+    out.index.push(...item.index);
+  }
+  validateOutput(out);
+  return out;
+}
+async function writeShadcnRegistry(out, options) {
+  const { dir, cleanDir = false, baseUrl } = options;
+  if (cleanDir) {
+    await fs2.rm(dir, {
+      recursive: true,
+      force: true
+    });
+    console.log(picocolors.bold(picocolors.greenBright("Cleaned directory")));
+  }
+  const { registry, index } = toShadcnRegistry(out, baseUrl);
+  const write = registry.items.map(async (item) => {
+    const file = path2.join(dir, `${item.name}.json`);
+    await writeFile2(file, JSON.stringify(item, null, 2));
+  });
+  write.push(
+    writeFile2(path2.join(dir, "registry.json"), JSON.stringify(index, null, 2))
+  );
+  await Promise.all(write);
+}
+async function writeFumadocsRegistry(out, options) {
+  const { dir, cleanDir = false, log = true } = options;
+  if (cleanDir) {
+    await fs2.rm(dir, {
+      recursive: true,
+      force: true
+    });
+    console.log(picocolors.bold(picocolors.greenBright("Cleaned directory")));
+  }
+  async function writeIndex() {
+    const file = path2.join(dir, "_registry.json");
+    const json = JSON.stringify(out.index, null, 2);
+    await writeFile2(file, json, log);
+  }
+  const write = out.components.map(async (comp) => {
+    const file = path2.join(dir, `${comp.name}.json`);
+    const json = JSON.stringify(comp, null, 2);
+    await writeFile2(file, json, log);
+  });
+  write.push(writeIndex());
+  await Promise.all(write);
+}
+async function writeFile2(file, content, log = true) {
+  await fs2.mkdir(path2.dirname(file), { recursive: true });
+  await fs2.writeFile(file, content);
+  if (log) {
+    const size = (Buffer.byteLength(content) / 1024).toFixed(2);
+    console.log(
+      `${picocolors.greenBright("+")} ${path2.relative(process.cwd(), file)} ${picocolors.dim(`${size} KB`)}`
+    );
+  }
+}
+export {
+  ComponentCompiler,
+  RegistryCompiler,
+  combineRegistry,
+  toShadcnRegistry,
+  writeFumadocsRegistry,
+  writeShadcnRegistry
+};

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,728 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import fs6 from "fs/promises";
+import path5 from "path";
+import { Command } from "commander";
+import picocolors3 from "picocolors";
+
+// src/config.ts
+import fs2 from "fs/promises";
+
+// src/utils/fs.ts
+import fs from "fs/promises";
+import path from "path";
+async function exists(pathLike) {
+  try {
+    await fs.access(pathLike);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/is-src.ts
+async function isSrc() {
+  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({})
+  });
+}
+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));
+}
+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;
+}
+
+// src/commands/file-tree.ts
+var 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)}>
+${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>
+${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)}
+
+export default (${treeToMdx(input, noRoot)})`;
+}
+
+// src/utils/file-tree/run-tree.ts
+import { x } from "tinyexec";
+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
+    });
+  }
+}
+
+// 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";
+
+// src/utils/typescript.ts
+import { Project } from "ts-morph";
+function createEmptyProject() {
+  return new Project({
+    compilerOptions: {}
+  });
+}
+
+// src/constants.ts
+var typescriptExtensions = [".ts", ".tsx", ".js", ".jsx"];
+
+// src/utils/ast.ts
+import path2 from "path";
+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}`;
+}
+
+// src/registry/installer/index.ts
+import { x as x3 } from "tinyexec";
+
+// src/registry/installer/dep-manager.ts
+import fs3 from "fs/promises";
+
+// src/utils/get-package-manager.ts
+import { detect } from "package-manager-detector";
+async function getPackageManager() {
+  const result = await detect();
+  return result?.name ?? "npm";
+}
+
+// src/registry/installer/dep-manager.ts
+import { confirm, isCancel, spinner } from "@clack/prompts";
+import { x as x2 } from "tinyexec";
+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.");
+  }
+};
+
+// 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
+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);
+  }
+};
+
+// 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);
+      })
+    );
+  }
+};
+
+// 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);
+}
+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")));
+}
+
+// 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!"));
+}
+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")
+  );
+}
+
+// src/index.ts
+var program = new Command().option("--config <string>");
+program.name("fumadocs").description("CLI to setup Fumadocs, 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."));
+  }
+});
+program.command("customise").alias("customize").description("simple way to customise layouts with Fumadocs 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));
+});
+var dirShortcuts = {
+  ":dev": "https://preview.fumadocs.dev/registry",
+  ":localhost": "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://fumadocs.dev/registry") {
+  if (dir in dirShortcuts) dir = dirShortcuts[dir];
+  return dir.startsWith("http://") || dir.startsWith("https://") ? remoteResolver(dir) : localResolver(dir);
+}
+program.parse();

package/package.json

@@ -0,0 +1,53 @@
+{
+  "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/*"
+  ],
+  "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",
+    "shadcn": "3.6.0",
+    "eslint-config-custom": "0.0.0",
+    "tsconfig": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf dist",
+    "dev": "tsup --watch",
+    "lint": "eslint .",
+    "types:check": "tsc --noEmit"
+  }
+}