@fumadocs/cli 0.2.0 → 1.0.0

package/dist/index.js

@@ -1,81 +1,29 @@
 #!/usr/bin/env node
-import {
-  exists,
-  isRelative
-} from "./chunk-DG6SFM2G.js";
 
 // src/index.ts
-import fs10 from "fs/promises";
-import path9 from "path";
+import fs5 from "fs/promises";
+import path4 from "path";
 import { Command } from "commander";
-import picocolors5 from "picocolors";
-import { isCancel as isCancel5, outro as outro4, select as select2 } from "@clack/prompts";
-
-// src/commands/init.ts
-import * as process2 from "process";
-import path3 from "path";
-import {
-  cancel,
-  confirm,
-  intro,
-  isCancel,
-  log,
-  note,
-  spinner
-} from "@clack/prompts";
-import picocolors from "picocolors";
-import { x } from "tinyexec";
-
-// src/utils/get-package-manager.ts
-import { detect } from "package-manager-detector";
-async function getPackageManager() {
-  const result = await detect();
-  return result?.name ?? "npm";
-}
-
-// src/utils/is-src.ts
-import path from "path";
-async function isSrc() {
-  return exists("./src");
-}
-function resolveAppPath(filePath, src2) {
-  return src2 ? path.join("./src", filePath) : filePath;
-}
+import picocolors3 from "picocolors";
 
-// src/config.ts
+// src/utils/add/install-component.ts
+import path2 from "path";
 import fs from "fs/promises";
-var src = await isSrc();
-var defaultConfig = {
-  aliases: {
-    cn: src ? "./src/lib/utils.ts" : "./lib/utils.ts",
-    componentsDir: src ? "./src/components" : "./components",
-    uiDir: src ? "./src/components/ui" : "./components/ui",
-    libDir: src ? "./src/lib" : "./lib"
-  }
-};
-async function loadConfig(file = "./cli.json") {
-  try {
-    const content = await fs.readFile(file);
-    return JSON.parse(content.toString());
-  } catch {
-    return {};
-  }
-}
-async function initConfig(file = "./cli.json") {
-  if (await fs.stat(file).then(() => true).catch(() => false)) {
-    return false;
-  }
-  await fs.writeFile(file, JSON.stringify(defaultConfig, null, 2));
-  return true;
-}
+import { confirm, isCancel, log, outro } from "@clack/prompts";
 
-// src/utils/transform-references.ts
-import path2 from "path";
+// 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/transform-references.ts
+import path from "path";
 function transformReferences(file, transform) {
   for (const specifier of file.getImportStringLiterals()) {
     const result = transform(specifier.getLiteralValue());
@@ -83,643 +31,267 @@ function transformReferences(file, transform) {
     specifier.setLiteralValue(result);
   }
 }
-function toReferencePath(sourceFile, referenceFile) {
-  const extname = path2.extname(referenceFile);
-  const importPath = path2.relative(
-    path2.dirname(sourceFile),
-    path2.join(
-      path2.dirname(referenceFile),
-      path2.basename(
-        referenceFile,
-        typescriptExtensions.includes(extname) ? extname : void 0
-      )
-    )
-  ).replaceAll(path2.sep, "/");
+function toImportSpecifier(sourceFile, referenceFile) {
+  const extname = path.extname(referenceFile);
+  const removeExt = typescriptExtensions.includes(extname);
+  const importPath = path.relative(
+    path.dirname(sourceFile),
+    removeExt ? referenceFile.substring(0, referenceFile.length - extname.length) : referenceFile
+  ).replaceAll(path.sep, "/");
   return importPath.startsWith("../") ? importPath : `./${importPath}`;
 }
-function resolveReference(ref, resolver) {
-  if (ref.startsWith("./") || ref.startsWith("../")) {
-    return {
-      type: "file",
-      path: path2.join(resolver.relativeTo, ref)
-    };
-  }
-  if (ref.startsWith("@/")) {
-    const rest = ref.slice("@/".length);
-    if (!resolver.alias) throw new Error("alias resolver is not configured");
-    return {
-      type: "file",
-      path: path2.join(resolver.alias.dir, rest)
-    };
-  }
-  if (ref.startsWith("@")) {
-    const segments = ref.split("/");
-    return {
-      type: "dep",
-      name: segments.slice(0, 2).join("/")
-    };
-  }
-  return {
-    type: "dep",
-    name: ref.split("/")[0]
-  };
-}
 
-// src/utils/typescript.ts
-import { Project } from "ts-morph";
-function createEmptyProject() {
-  return new Project({
-    compilerOptions: {}
-  });
+// src/registry/schema.ts
+import { z } from "zod";
+var namespaces = [
+  "components",
+  "lib",
+  "css",
+  "route",
+  "ui",
+  "block"
+];
+var indexSchema = z.object({
+  name: z.string(),
+  title: z.string().optional(),
+  description: z.string().optional()
+});
+var fileSchema = z.object({
+  type: z.literal(namespaces),
+  path: z.string(),
+  target: z.string().optional(),
+  content: z.string()
+});
+var 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()).default([])
+});
+var rootSchema = z.object({
+  name: z.string(),
+  index: z.array(indexSchema),
+  components: z.array(componentSchema)
+});
+
+// src/registry/client.ts
+import { z as z2 } from "zod";
+function validateRegistryIndex(indexes) {
+  return z2.array(indexSchema).parse(indexes);
+}
+function validateRegistryComponent(component) {
+  return componentSchema.parse(component);
 }
 
-// src/commands/init.ts
-async function init(plugin, config = {}) {
-  intro(
-    picocolors.bgCyan(picocolors.black(picocolors.bold("Installing Plugins")))
-  );
-  const ctx = {
-    src: await isSrc(),
-    outFileMap: /* @__PURE__ */ new Map(),
-    ...config
-  };
-  const files = await plugin.files(ctx);
+// src/utils/add/install-component.ts
+function createComponentInstaller(options) {
+  const { config, resolver } = options;
   const project = createEmptyProject();
-  for (const [name, content] of Object.entries(files)) {
-    const file = getOutputPath(name, ctx);
-    ctx.outFileMap.set(name, file);
-    log.step(picocolors.green(`Writing ${file} \u2605`));
-    if (await exists(file)) {
-      const value = await confirm({
-        message: `${file} already exists`,
-        active: "Override",
-        inactive: "Skip"
-      });
-      if (isCancel(value)) {
-        cancel("Operation cancelled.");
-        process2.exit(0);
+  const installedFiles = /* @__PURE__ */ new Set();
+  const downloadedComps = /* @__PURE__ */ new Map();
+  function 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);
       }
-      if (!value) continue;
     }
-    const sourceFile = project.createSourceFile(file, content, {
-      overwrite: true
-    });
-    transformReferences(sourceFile, (specifier) => {
-      const resolved = resolveReference(specifier, {
-        alias: {
-          type: "append",
-          dir: ctx.src ? "src" : ""
-        },
-        relativeTo: path3.dirname(file)
-      });
-      if (resolved.type !== "file") return;
-      return toReferencePath(file, getOutputPath(resolved.path, ctx));
-    });
-    await sourceFile.save();
+    return Array.from(map.values());
   }
-  if (plugin.dependencies.length > 0) {
-    const manager = await getPackageManager();
-    const value = await confirm({
-      message: `This plugin contains additional dependencies, do you want to install them? (detected: ${manager})`
-    });
-    if (isCancel(value)) {
-      cancel("Operation cancelled.");
-      process2.exit(0);
-    }
-    if (value) {
-      const spin = spinner();
-      spin.start("Installing dependencies");
-      await x(manager, ["install", ...plugin.dependencies]);
-      spin.stop("Successfully installed.");
-    }
-  }
-  if (plugin.transform) {
-    const value = await confirm({
-      message: "This plugin contains changes to your files, do you want to apply them?"
-    });
-    if (isCancel(value)) {
-      cancel("Operation cancelled.");
-      process2.exit(0);
-    }
-    if (value) {
-      await plugin.transform(ctx);
-      note(
-        `You can format the output with Prettier or other code formatting tools
-prettier . --write`,
-        picocolors.bold(picocolors.green("Changes Applied"))
+  return {
+    async install(name) {
+      const downloaded = await this.download(name);
+      const dependencies = {};
+      const devDependencies = {};
+      for (const item of downloaded) {
+        Object.assign(dependencies, item.dependencies);
+        Object.assign(devDependencies, item.devDependencies);
+      }
+      const fileList = buildFileList(downloaded);
+      for (const file of fileList) {
+        const filePath = file.target ?? file.path;
+        if (installedFiles.has(filePath)) continue;
+        const outPath = this.resolveOutputPath(file);
+        const output = typescriptExtensions.includes(path2.extname(filePath)) ? this.transform(outPath, file, fileList) : file.content;
+        const status = await fs.readFile(outPath).then((res) => {
+          if (res.toString() === output) return "ignore";
+          return "need-update";
+        }).catch(() => "write");
+        installedFiles.add(filePath);
+        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(path2.dirname(outPath), { recursive: true });
+        await fs.writeFile(outPath, output);
+        log.step(`downloaded ${outPath}`);
+      }
+      return {
+        dependencies,
+        devDependencies
+      };
+    },
+    /**
+     * return a list of components, merged with child components.
+     */
+    async download(name) {
+      const cached = downloadedComps.get(name);
+      if (cached) return cached;
+      const comp = validateRegistryComponent(
+        await resolver(`${name}.json`).catch((e) => {
+          log.error(`component ${name} not found:`);
+          log.error(String(e));
+          process.exit(1);
+        })
       );
-    } else {
-      await plugin.transformRejected?.(ctx);
-    }
-  }
-  const instructions = await plugin.instructions(ctx);
-  for (const text of instructions) {
-    if (text.type === "text") {
-      log.message(text.text, {
-        symbol: "\u25CB"
+      const result = [comp];
+      downloadedComps.set(name, result);
+      for (const sub of comp.subComponents) {
+        result.push(...await this.download(sub));
+      }
+      return result;
+    },
+    transform(filePath, file, fileList) {
+      const sourceFile = project.createSourceFile(filePath, file.content, {
+        overwrite: true
       });
-    }
-    if (text.type === "code") {
-      note(text.code, text.title);
-    }
-    if (text.type === "title") {
-      log.step(text.text);
-    }
-  }
-}
-function getOutputPath(ref, config) {
-  if (path3.isAbsolute(ref)) throw new Error(`path cannot be absolute: ${ref}`);
-  if (ref === "utils/cn" || ref === "utils/cn.ts") {
-    return config.aliases?.cn ?? defaultConfig.aliases.cn;
-  }
-  if (ref.startsWith("components")) {
-    return path3.join(
-      config.aliases?.componentsDir ?? defaultConfig.aliases.componentsDir,
-      path3.relative("components", ref)
-    );
-  }
-  if (ref.startsWith("lib") || ref.startsWith("utils")) {
-    return path3.join(
-      config.aliases?.libDir ?? defaultConfig.aliases.libDir,
-      path3.relative("lib", ref)
-    );
-  }
-  return ref;
-}
-
-// src/utils/add/install-component.ts
-import path4 from "path";
-import fs2 from "fs/promises";
-import { confirm as confirm2, isCancel as isCancel2, log as log2, outro } from "@clack/prompts";
-var downloadedFiles = /* @__PURE__ */ new Set();
-async function installComponent(name, resolver, config = {}) {
-  const project = createEmptyProject();
-  return downloadComponent(name, {
-    project,
-    config,
-    resolver
-  });
-}
-var downloadedComps = /* @__PURE__ */ new Map();
-async function downloadComponent(name, ctx) {
-  const cached = downloadedComps.get(name);
-  if (cached) return cached;
-  const comp = await ctx.resolver(`${name}.json`);
-  if (!comp) return;
-  downloadedComps.set(name, comp);
-  for (const file of comp.files) {
-    if (downloadedFiles.has(file.path)) continue;
-    const outPath = resolveOutputPath(file.path, ctx.config);
-    const output = typescriptExtensions.includes(path4.extname(file.path)) ? transformTypeScript(outPath, file, ctx) : file.content;
-    let canWrite = true;
-    const requireOverride = await fs2.readFile(outPath).then((res) => res.toString() !== output).catch(() => false);
-    if (requireOverride) {
-      const value = await confirm2({
-        message: `Do you want to override ${outPath}?`
+      transformReferences(sourceFile, (specifier) => {
+        const prefix = "@/";
+        if (specifier.startsWith(prefix)) {
+          const lookup = specifier.substring(prefix.length);
+          const target = fileList.find((item) => {
+            const filePath2 = item.target ?? item.path;
+            return filePath2 === lookup;
+          });
+          if (!target) {
+            console.warn(`cannot find the referenced file of ${specifier}`);
+            return specifier;
+          }
+          return toImportSpecifier(filePath, this.resolveOutputPath(target));
+        }
       });
-      if (isCancel2(value)) {
-        outro("Ended");
-        process.exit(0);
+      return sourceFile.getFullText();
+    },
+    resolveOutputPath(ref) {
+      if (ref.target) {
+        return path2.join(config.baseDir, ref.target);
       }
-      canWrite = value;
+      const base = path2.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 path2.join(config.baseDir, dir, base);
     }
-    if (canWrite) {
-      await fs2.mkdir(path4.dirname(outPath), { recursive: true });
-      await fs2.writeFile(outPath, output);
-      log2.step(`downloaded ${outPath}`);
-    }
-    downloadedFiles.add(file.path);
-  }
-  for (const sub of comp.subComponents) {
-    const downloaded = await downloadComponent(sub, ctx);
-    if (!downloaded) continue;
-    Object.assign(comp.dependencies, downloaded.dependencies);
-    Object.assign(comp.devDependencies, downloaded.devDependencies);
-  }
-  return comp;
-}
-function resolveOutputPath(ref, config) {
-  const sep = ref.indexOf(":");
-  if (sep === -1) return ref;
-  const namespace = ref.slice(0, sep), file = ref.slice(sep + 1);
-  if (namespace === "components") {
-    return path4.join(
-      config.aliases?.componentsDir ?? defaultConfig.aliases.componentsDir,
-      file
-    );
-  }
-  return path4.join(
-    config.aliases?.libDir ?? defaultConfig.aliases.libDir,
-    file
-  );
-}
-function transformTypeScript(filePath, file, ctx) {
-  const sourceFile = ctx.project.createSourceFile(filePath, file.content, {
-    overwrite: true
-  });
-  transformReferences(sourceFile, (specifier) => {
-    if (specifier in file.imports) {
-      const outputPath = resolveOutputPath(file.imports[specifier], ctx.config);
-      return toReferencePath(filePath, outputPath);
-    }
-  });
-  return sourceFile.getFullText();
+  };
 }
 function remoteResolver(url) {
   return async (file) => {
     const res = await fetch(`${url}/${file}`);
-    if (!res.ok) return;
-    return res.json();
+    if (!res.ok) {
+      throw new Error(`failed to fetch ${url}/${file}: ${res.statusText}`);
+    }
+    return await res.json();
   };
 }
 function localResolver(dir) {
   return async (file) => {
-    return await fs2.readFile(path4.join(dir, file)).then((res) => JSON.parse(res.toString())).catch(() => void 0);
+    const filePath = path2.join(dir, file);
+    return await fs.readFile(filePath).then((res) => JSON.parse(res.toString())).catch((e) => {
+      throw new Error(`failed to resolve local file "${filePath}"`, {
+        cause: e
+      });
+    });
   };
 }
 
-// src/plugins/i18n.ts
-import path7 from "path";
-import { log as log3 } from "@clack/prompts";
-
-// src/generated.js
-var generated = { "lib/i18n": "import type { I18nConfig } from 'fumadocs-core/i18n';\n\nexport const i18n: I18nConfig = {\n  defaultLanguage: 'en',\n  languages: ['en', 'cn'],\n};\n", "middleware": "import { createI18nMiddleware } from 'fumadocs-core/i18n';\nimport { i18n } from '@/lib/i18n';\n\nexport default createI18nMiddleware(i18n);\n\nexport const config = {\n  // Matcher ignoring `/_next/` and `/api/`\n  matcher: ['/((?!api|_next/static|_next/image|favicon.ico).*)'],\n};\n", "scripts/generate-docs": "import * as OpenAPI from 'fumadocs-openapi';\nimport { rimraf } from 'rimraf';\n\nconst out = './content/docs/(api)';\n\nasync function generate() {\n  // clean generated files\n  await rimraf(out, {\n    filter(v) {\n      return !v.endsWith('index.mdx') && !v.endsWith('meta.json');\n    },\n  });\n\n  await OpenAPI.generateFiles({\n    // input files\n    input: ['./openapi.json'],\n    output: out,\n  });\n}\n\nvoid generate();\n" };
-
-// src/utils/i18n/transform-layout-config.ts
+// src/config.ts
 import fs3 from "fs/promises";
-import { SyntaxKind } from "ts-morph";
-async function transformLayoutConfig(project, filePath) {
-  let content;
-  try {
-    content = await fs3.readFile(filePath).then((res) => res.toString());
-  } catch {
-    return;
-  }
-  const sourceFile = project.createSourceFile(filePath, content, {
-    overwrite: true
-  });
-  const configExport = sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration).find((node) => node.getName() === "baseOptions");
-  if (!configExport) return;
-  const init2 = configExport.getInitializerIfKind(
-    SyntaxKind.ObjectLiteralExpression
-  );
-  if (!init2) return;
-  if (init2.getProperty("i18n")) return;
-  init2.addPropertyAssignment({
-    name: "i18n",
-    initializer: "true"
-  });
-  return sourceFile.save();
-}
-
-// src/utils/move-files.ts
-import fs4 from "fs/promises";
-import path5 from "path";
-var transformExtensions = [".js", ".ts", ".tsx", ".jsx"];
-async function moveFiles(from, to, filter, project, src2, originalDir = from) {
-  function isIncluded(file) {
-    if (!transformExtensions.includes(path5.extname(file))) return false;
-    return filter(path5.resolve(file));
-  }
-  const stats = await fs4.lstat(from).catch(() => void 0);
-  if (!stats) return;
-  if (stats.isDirectory()) {
-    const items = await fs4.readdir(from);
-    await Promise.all(
-      items.map(async (item) => {
-        await moveFiles(
-          path5.join(from, item),
-          path5.join(to, item),
-          filter,
-          project,
-          src2,
-          originalDir
-        );
-      })
-    );
-    await fs4.rmdir(from).catch(() => {
-    });
-  }
-  if (!stats.isFile() || !isIncluded(from)) return;
-  const content = await fs4.readFile(from);
-  const sourceFile = project.createSourceFile(from, content.toString(), {
-    overwrite: true
-  });
-  transformReferences(sourceFile, (specifier) => {
-    const resolved = resolveReference(specifier, {
-      alias: {
-        type: "append",
-        dir: src2 ? "src" : ""
-      },
-      relativeTo: path5.dirname(from)
-    });
-    if (resolved.type !== "file") return;
-    if (
-      // ignore if the file is also moved
-      isRelative(originalDir, from) && isIncluded(resolved.path)
-    )
-      return;
-    return toReferencePath(to, resolved.path);
-  });
-  await sourceFile.save();
-  await fs4.mkdir(path5.dirname(to), { recursive: true });
-  await fs4.rename(from, to);
-}
 
-// src/utils/i18n/transform-source-i18n.ts
-import * as fs5 from "fs/promises";
-import path6 from "path";
-import { StructureKind, SyntaxKind as SyntaxKind2 } from "ts-morph";
-async function transformSourceI18n(project, filePath, config) {
-  let content;
+// src/utils/fs.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+async function exists(pathLike) {
   try {
-    content = await fs5.readFile(filePath).then((res) => res.toString());
+    await fs2.access(pathLike);
+    return true;
   } catch {
-    return;
+    return false;
   }
-  const sourceFile = project.createSourceFile(filePath, content, {
-    overwrite: true
-  });
-  sourceFile.addImportDeclaration({
-    kind: StructureKind.ImportDeclaration,
-    moduleSpecifier: toReferencePath(
-      filePath,
-      path6.join(config.aliases?.libDir ?? defaultConfig.aliases.libDir, "i18n")
-    ),
-    namedImports: ["i18n"]
-  });
-  const sourceExport = sourceFile.getDescendantsOfKind(SyntaxKind2.VariableDeclaration).find((node) => node.getName() === "source");
-  if (!sourceExport) return;
-  const loaderCall = sourceExport.getFirstDescendantByKind(
-    SyntaxKind2.ObjectLiteralExpression
-  );
-  if (!loaderCall || loaderCall.getProperty("i18n")) return;
-  loaderCall.addPropertyAssignment({
-    name: "i18n",
-    initializer: "i18n"
-  });
-  return sourceFile.save();
 }
 
-// src/utils/i18n/transform-root-layout.ts
-import fs6 from "fs/promises";
-import { StructureKind as StructureKind2, ts } from "ts-morph";
-var ScriptKind = ts.ScriptKind;
-var SyntaxKind3 = ts.SyntaxKind;
-async function transformRootLayout(project, filePath) {
-  let content;
-  try {
-    content = await fs6.readFile(filePath).then((res) => res.toString());
-  } catch {
-    return;
-  }
-  const sourceFile = project.createSourceFile(filePath, content, {
-    overwrite: true,
-    scriptKind: ScriptKind.TSX
-  });
-  runTransform(sourceFile);
-  return sourceFile.save();
+// src/utils/is-src.ts
+async function isSrc() {
+  return exists("./src");
 }
-function runTransform(sourceFile) {
-  const rootProvider = sourceFile.getDescendantsOfKind(SyntaxKind3.JsxElement).find(
-    (node) => node.getOpeningElement().getTagNameNode().getFullText() === "RootProvider"
-  );
-  if (!rootProvider) return;
-  const parent = rootProvider.getParentIfKind(SyntaxKind3.JsxElement);
-  if (parent) {
-    const inner = parent.getJsxChildren().map((v) => v.getFullText()).filter((v) => v.length > 0).join("\n");
-    parent.setBodyText(
-      `<I18nProvider locale={(await params).lang} locales={[
-    { locale: 'en', name: 'English' }
-]}>
-  ${inner.trim()}
-</I18nProvider>`
-    );
-    sourceFile.addImportDeclaration({
-      kind: StructureKind2.ImportDeclaration,
-      moduleSpecifier: "fumadocs-ui/i18n",
-      namedImports: ["I18nProvider"]
-    });
-  }
-  const func = sourceFile.getDescendantsOfKind(SyntaxKind3.FunctionDeclaration).find((v) => v.isDefaultExport());
-  func?.toggleModifier("async", true);
-  const param = func?.getParameters().at(0);
-  param?.setType(`{ params: Promise<{ lang: string }>, children: ReactNode }`);
-  param?.set({
-    name: `{ params, children }`
+
+// src/config.ts
+import { z as z3 } from "zod";
+function createConfigSchema(isSrc2) {
+  const defaultAliases = {
+    uiDir: "./components/ui",
+    componentsDir: "./components",
+    blockDir: "./components",
+    cssDir: "./styles",
+    libDir: "./lib"
+  };
+  return z3.object({
+    aliases: z3.object({
+      uiDir: z3.string().default(defaultAliases.uiDir),
+      componentsDir: z3.string().default(defaultAliases.uiDir),
+      blockDir: z3.string().default(defaultAliases.blockDir),
+      cssDir: z3.string().default(defaultAliases.componentsDir),
+      libDir: z3.string().default(defaultAliases.libDir)
+    }).default(defaultAliases),
+    baseDir: z3.string().default(isSrc2 ? "src" : ""),
+    commands: z3.object({
+      /**
+       * command to format output code automatically
+       */
+      format: z3.string().optional()
+    }).default({})
   });
 }
-
-// src/plugins/i18n.ts
-import picocolors2 from "picocolors";
-var i18nPlugin = {
-  files: ({ src: src2 }) => ({
-    "lib/i18n.ts": generated["lib/i18n"],
-    [src2 ? "src/middleware.ts" : "middleware.ts"]: generated.middleware
-  }),
-  dependencies: [],
-  instructions: () => [
-    {
-      type: "title",
-      text: `1. Update the params of ${picocolors2.bold("page.tsx")} and ${picocolors2.bold("layout.tsx")}, and make them async if necessary.`
-    },
-    {
-      type: "code",
-      title: "layout.tsx",
-      code: `
-export default async function Layout({
-  params,
-}: {
-  ${picocolors2.underline(picocolors2.bold("params: Promise<{ lang: string }>"))}
-})
-`.trim()
-    },
-    {
-      type: "code",
-      title: "page.tsx",
-      code: `
-export default async function Page({
-  params,
-}: {
-  ${picocolors2.underline(picocolors2.bold("params: Promise<{ lang: string; slug?: string[] }>"))}
-})
-`.trim()
-    },
-    {
-      type: "title",
-      text: "2. Update references to your `source` object"
-    },
-    {
-      type: "text",
-      text: "You can follow the instructions in https://fumadocs.vercel.app/docs/ui/internationalization#source section."
-    }
-  ],
-  async transform(ctx) {
-    const project = createEmptyProject();
-    await Promise.all([
-      transformLayoutConfig(
-        project,
-        resolveAppPath("./app/layout.config.tsx", ctx.src)
-      ),
-      transformRootLayout(project, resolveAppPath("./app/layout.tsx", ctx.src)),
-      transformSourceI18n(
-        project,
-        path7.join(
-          ctx.aliases?.libDir ?? defaultConfig.aliases.libDir,
-          "source.ts"
-        ),
-        ctx
-      )
-    ]);
-    await moveFiles(
-      resolveAppPath("./app", ctx.src),
-      resolveAppPath("./app/[lang]", ctx.src),
-      (v) => {
-        const parsed = path7.parse(v);
-        if (parsed.ext === ".css") return false;
-        return parsed.name !== "layout.config" && !isRelative("./app/api", v);
-      },
-      project,
-      ctx.src
-    );
-    log3.success(
-      "Moved the ./app files to a [lang] route group, and modified your root layout to add `<I18nProvider />`."
-    );
-  },
-  transformRejected() {
-    log3.info(
-      `Please create a [lang] route group and move all special files into the folder.
-See https://nextjs.org/docs/app/building-your-application/routing/internationalization for more info.`
-    );
-  }
-};
-
-// src/plugins/openapi.ts
-import fs8 from "fs/promises";
-import path8 from "path";
-import { StructureKind as StructureKind3 } from "ts-morph";
-
-// src/utils/transform-tailwind.ts
-import fs7 from "fs/promises";
-import { SyntaxKind as SyntaxKind4 } from "ts-morph";
-import { log as log4 } from "@clack/prompts";
-var tailwindConfigPaths = [
-  "tailwind.config.js",
-  "tailwind.config.mjs",
-  "tailwind.config.ts",
-  "tailwind.config.mts"
-];
-async function findTailwindConfig() {
-  for (const configPath of tailwindConfigPaths) {
-    if (await exists(configPath)) {
-      return configPath;
-    }
-  }
+async function createOrLoadConfig(file = "./cli.json") {
+  const inited = await initConfig(file);
+  if (inited) return inited;
+  const content = (await fs3.readFile(file)).toString();
+  const src = await isSrc();
+  const configSchema = createConfigSchema(src);
+  return configSchema.parse(JSON.parse(content));
 }
-async function transformTailwind(project, options) {
-  const file = await findTailwindConfig();
-  if (!file) {
-    log4.error(
-      "Cannot find Tailwind CSS configuration file, Tailwind CSS is required for this."
-    );
+async function initConfig(file = "./cli.json") {
+  if (await fs3.stat(file).then(() => true).catch(() => false)) {
     return;
   }
-  const configFile = project.createSourceFile(
-    file,
-    await fs7.readFile(file).then((res) => res.toString()),
-    { overwrite: true }
-  );
-  const exports = configFile.getExportAssignments();
-  if (exports.length === 0) return;
-  const contentNode = exports[0].getDescendantsOfKind(SyntaxKind4.PropertyAssignment).find((a) => a.getName() === "content");
-  if (!contentNode) throw new Error("No `content` detected");
-  const arr = contentNode.getFirstDescendantByKind(
-    SyntaxKind4.ArrayLiteralExpression
-  );
-  arr?.addElements(options.addContents.map((v) => JSON.stringify(v)));
-  await configFile.save();
-}
-
-// src/plugins/openapi.ts
-var openapiPlugin = {
-  files: () => ({
-    "scripts/generate-docs.mjs": generated["scripts/generate-docs"]
-  }),
-  dependencies: ["fumadocs-openapi", "rimraf", "shiki"],
-  async transform(ctx) {
-    const project = createEmptyProject();
-    await Promise.all([
-      transformSource(project, ctx),
-      transformTailwind(project, {
-        addContents: [`./node_modules/fumadocs-openapi/dist/**/*.js`]
-      }),
-      addScript()
-    ]);
-  },
-  instructions: async () => [
-    {
-      type: "text",
-      text: `I've made some changes to your Tailwind CSS config.
-You can add the APIPage component to your page.tsx:`
-    },
-    {
-      type: "code",
-      title: "page.tsx",
-      code: `import defaultMdxComponents from 'fumadocs-ui/mdx';
-import { openapi } from '@/lib/source';
- 
-<MDX
-  components={{
-    ...defaultMdxComponents,
-    APIPage: openapi.APIPage,
-  }}
-/>;`
-    },
-    {
-      type: "text",
-      text: `Paste your OpenAPI schema to ./openapi.json, and use this script to generate docs:`
-    },
-    {
-      type: "code",
-      title: "Terminal",
-      code: `${await getPackageManager()} run build:docs`
-    }
-  ]
-};
-async function addScript() {
-  const content = await fs8.readFile("package.json");
-  const parsed = JSON.parse(content.toString());
-  if (typeof parsed.scripts !== "object") return;
-  parsed.scripts ??= {};
-  Object.assign(parsed.scripts ?? {}, {
-    "build:docs": "node ./scripts/generate-docs.mjs"
-  });
-  await fs8.writeFile("package.json", JSON.stringify(parsed, null, 2));
-}
-async function transformSource(project, config) {
-  const source = path8.join(
-    config.aliases?.libDir ?? defaultConfig.aliases.libDir,
-    "source.ts"
-  );
-  const content = await fs8.readFile(source).catch(() => "");
-  const file = project.createSourceFile(source, content.toString(), {
-    overwrite: true
-  });
-  file.addImportDeclaration({
-    kind: StructureKind3.ImportDeclaration,
-    namedImports: ["createOpenAPI"],
-    moduleSpecifier: "fumadocs-openapi/server"
-  });
-  file.addStatements(`export const openapi = createOpenAPI();`);
-  await file.save();
+  const src = await isSrc();
+  const defaultConfig = createConfigSchema(src).parse({});
+  await fs3.writeFile(file, JSON.stringify(defaultConfig, null, 2));
+  return defaultConfig;
 }
 
-// src/plugins/index.ts
-var plugins = {
-  i18n: i18nPlugin,
-  openapi: openapiPlugin
-};
-
 // src/commands/file-tree.ts
 var scanned = ["file", "directory", "link"];
 function treeToMdx(input, noRoot = false) {
@@ -756,9 +328,9 @@ export default (${treeToMdx(input, noRoot)})`;
 }
 
 // src/utils/file-tree/run-tree.ts
-import { x as x2 } from "tinyexec";
+import { x } from "tinyexec";
 async function runTree(args) {
-  const out = await x2("tree", [args, "--gitignore", "--prune", "-J"]);
+  const out = await x("tree", [args, "--gitignore", "--prune", "-J"]);
   try {
     return JSON.parse(out.stdout);
   } catch (e) {
@@ -771,7 +343,7 @@ async function runTree(args) {
 // package.json
 var package_default = {
   name: "@fumadocs/cli",
-  version: "0.2.0",
+  version: "1.0.0",
   description: "The CLI tool for Fumadocs",
   keywords: [
     "NextJs",
@@ -805,19 +377,20 @@ var package_default = {
     "types:check": "tsc --noEmit"
   },
   dependencies: {
-    "@clack/prompts": "^0.10.1",
+    "@clack/prompts": "^0.11.0",
     commander: "^14.0.0",
     "package-manager-detector": "^1.3.0",
     picocolors: "^1.1.1",
     tinyexec: "^1.0.1",
-    "ts-morph": "^26.0.0"
+    "ts-morph": "^26.0.0",
+    zod: "^4.0.17"
   },
   devDependencies: {
-    "@types/node": "22.15.19",
-    "@types/react": "^19.1.4",
+    shadcn: "2.9.3-canary.0",
+    "@types/node": "24.2.1",
     "eslint-config-custom": "workspace:*",
     tsconfig: "workspace:*",
-    tsx: "^4.19.4"
+    tsx: "^4.20.3"
   },
   publishConfig: {
     access: "public"
@@ -826,37 +399,44 @@ var package_default = {
 
 // src/commands/customise.ts
 import {
-  cancel as cancel2,
-  confirm as confirm4,
+  cancel,
+  confirm as confirm3,
   group,
-  intro as intro3,
-  log as log6,
+  intro as intro2,
+  log as log3,
   outro as outro3,
   select
 } from "@clack/prompts";
-import picocolors4 from "picocolors";
+import picocolors2 from "picocolors";
 
 // src/commands/add.ts
 import {
-  intro as intro2,
-  isCancel as isCancel4,
-  log as log5,
+  intro,
+  isCancel as isCancel3,
+  log as log2,
   multiselect,
   outro as outro2,
-  spinner as spinner3
+  spinner as spinner2
 } from "@clack/prompts";
-import picocolors3 from "picocolors";
+import picocolors from "picocolors";
+
+// src/utils/get-package-manager.ts
+import { detect } from "package-manager-detector";
+async function getPackageManager() {
+  const result = await detect();
+  return result?.name ?? "npm";
+}
 
 // src/utils/add/install-deps.ts
-import { confirm as confirm3, isCancel as isCancel3, spinner as spinner2 } from "@clack/prompts";
-import { x as x3 } from "tinyexec";
+import { confirm as confirm2, isCancel as isCancel2, spinner } from "@clack/prompts";
+import { x as x2 } from "tinyexec";
 
 // src/utils/add/get-deps.ts
-import fs9 from "fs/promises";
+import fs4 from "fs/promises";
 async function getDeps() {
   const dependencies = /* @__PURE__ */ new Map();
   if (!await exists("package.json")) return dependencies;
-  const content = await fs9.readFile("package.json");
+  const content = await fs4.readFile("package.json");
   const parsed = JSON.parse(content.toString());
   if ("dependencies" in parsed && typeof parsed.dependencies === "object") {
     const records = parsed.dependencies;
@@ -874,30 +454,27 @@ async function getDeps() {
 }
 
 // src/utils/add/install-deps.ts
-async function installDeps(results) {
+async function installDeps(deps, devDeps) {
   const installed = await getDeps();
-  const deps = {};
-  const devDeps = {};
-  for (const result of results) {
-    Object.assign(deps, result.dependencies);
-    Object.assign(devDeps, result.devDependencies);
+  function toList(deps2) {
+    return Object.entries(deps2).filter(([k]) => !installed.has(k)).map(([k, v]) => v === null || v.length === 0 ? k : `${k}@${v}`);
   }
-  const items = Object.entries(deps).filter(([k]) => !installed.has(k)).map(([k, v]) => v.length === 0 ? k : `${k}@${v}`);
-  const devItems = Object.entries(devDeps).filter(([k]) => !installed.has(k)).map(([k, v]) => v.length === 0 ? k : `${k}@${v}`);
+  const items = toList(deps);
+  const devItems = toList(devDeps);
   if (items.length > 0 || devItems.length > 0) {
     const manager = await getPackageManager();
-    const value = await confirm3({
+    const value = await confirm2({
       message: `Do you want to install with ${manager}?
 ${[...items, ...devItems].map((v) => `- ${v}`).join("\n")}`
     });
-    if (isCancel3(value)) {
+    if (isCancel2(value)) {
       return;
     }
     if (value) {
-      const spin = spinner2();
+      const spin = spinner();
       spin.start("Installing dependencies...");
-      if (items.length > 0) await x3(manager, ["install", ...items]);
-      if (devItems.length > 0) await x3(manager, ["install", ...devItems, "-D"]);
+      if (items.length > 0) await x2(manager, ["install", ...items]);
+      if (devItems.length > 0) await x2(manager, ["install", ...devItems, "-D"]);
       spin.stop("Dependencies installed.");
     }
   }
@@ -905,56 +482,68 @@ ${[...items, ...devItems].map((v) => `- ${v}`).join("\n")}`
 
 // src/commands/add.ts
 async function add(input, resolver, config) {
+  const installer = createComponentInstaller({
+    resolver,
+    config
+  });
   let target = input;
   if (input.length === 0) {
-    const spin = spinner3();
+    const spin = spinner2();
     spin.start("fetching registry");
-    const registry = await resolver("_registry.json");
-    spin.stop(picocolors3.bold(picocolors3.greenBright("registry fetched")));
-    if (!registry) {
-      log5.error(`Failed to fetch '_registry.json' file from registry`);
-      throw new Error(`Failed to fetch registry`);
-    }
+    const indexes = validateRegistryIndex(
+      await resolver("_registry.json").catch((e) => {
+        log2.error(String(e));
+        process.exit(1);
+      })
+    );
+    spin.stop(picocolors.bold(picocolors.greenBright("registry fetched")));
     const value = await multiselect({
       message: "Select components to install",
-      options: registry.map((item) => ({
-        label: item.name,
+      options: indexes.map((item) => ({
+        label: item.title,
         value: item.name,
         hint: item.description
       }))
     });
-    if (isCancel4(value)) {
+    if (isCancel3(value)) {
       outro2("Ended");
       return;
     }
     target = value;
   }
-  await install(target, resolver, config);
+  await install(target, installer);
 }
-async function install(target, resolver, config) {
-  const outputs = [];
+async function install(target, installer) {
+  const dependencies = {};
+  const devDependencies = {};
   for (const name of target) {
-    intro2(
-      picocolors3.bold(
-        picocolors3.inverse(picocolors3.cyanBright(`Add Component: ${name}`))
+    intro(
+      picocolors.bold(
+        picocolors.inverse(picocolors.cyanBright(`Add Component: ${name}`))
       )
     );
-    const output = await installComponent(name, resolver, config);
-    if (!output) {
-      log5.error(`Failed to install ${name}: not found`);
-      continue;
+    try {
+      const output = await installer.install(name);
+      Object.assign(dependencies, output.dependencies);
+      Object.assign(devDependencies, output.devDependencies);
+      outro2(picocolors.bold(picocolors.greenBright(`${name} installed`)));
+    } catch (e) {
+      log2.error(String(e));
+      throw e;
     }
-    outro2(picocolors3.bold(picocolors3.greenBright(`${name} installed`)));
-    outputs.push(output);
   }
-  intro2(picocolors3.bold("New Dependencies"));
-  await installDeps(outputs);
-  outro2(picocolors3.bold(picocolors3.greenBright("Successful")));
+  intro(picocolors.bold("New Dependencies"));
+  await installDeps(dependencies, devDependencies);
+  outro2(picocolors.bold(picocolors.greenBright("Successful")));
 }
 
 // src/commands/customise.ts
 async function customise(resolver, config) {
-  intro3(picocolors4.bgBlack(picocolors4.whiteBright("Customise Fumadocs UI")));
+  intro2(picocolors2.bgBlack(picocolors2.whiteBright("Customise Fumadocs UI")));
+  const installer = createComponentInstaller({
+    resolver,
+    config
+  });
   const result = await group(
     {
       target: () => select({
@@ -998,14 +587,14 @@ async function customise(resolver, config) {
       page: async (v) => {
         if (v.results.target !== "docs" || v.results.mode === "minimal")
           return false;
-        return confirm4({
+        return confirm3({
           message: "Do you want to customise the page component too?"
         });
       }
     },
     {
       onCancel: () => {
-        cancel2("Installation Stopped.");
+        cancel("Installation Stopped.");
         process.exit(0);
       }
     }
@@ -1025,72 +614,47 @@ async function customise(resolver, config) {
         result.mode === "full-default" ? "layouts/docs" : "layouts/notebook"
       );
     }
-    await install(targets, resolver, config);
-    intro3(picocolors4.bold("What is Next?"));
-    log6.info(
-      [
-        "You can check the installed components in `components/layouts`.",
-        picocolors4.dim("---"),
-        "Open your `layout.tsx` files, replace the imports of components:",
-        picocolors4.greenBright(
-          "`fumadocs-ui/layouts/docs` -> `@/components/layouts/docs`"
-        ),
-        pageAdded ? picocolors4.greenBright(
-          "`fumadocs-ui/page` -> `@/components/layouts/page`"
-        ) : ""
-      ].join("\n")
-    );
+    await install(targets, installer);
+    const maps = [
+      ["fumadocs-ui/layouts/docs", "@/components/layout/docs"]
+    ];
+    if (pageAdded) {
+      maps.push(["fumadocs-ui/page", "@/components/layout/page"]);
+    }
+    printNext(...maps);
   }
   if (result.target === "home") {
-    await install(["layouts/home"], resolver, config);
-    intro3(picocolors4.bold("What is Next?"));
-    log6.info(
-      [
-        "You can check the installed components in `components/layouts`.",
-        picocolors4.dim("---"),
-        "Open your `layout.tsx` files, replace the imports of components:",
-        picocolors4.greenBright(
-          "`fumadocs-ui/layouts/home` -> `@/components/layouts/home`"
-        )
-      ].join("\n")
-    );
-  }
-  outro3(picocolors4.bold("Have fun!"));
+    await install(["layouts/home"], installer);
+    printNext(["fumadocs-ui/layouts/home", `@/components/layout/home`]);
+  }
+  outro3(picocolors2.bold("Have fun!"));
+}
+function printNext(...maps) {
+  intro2(picocolors2.bold("What is Next?"));
+  log3.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 () => {
+program.name("fumadocs").description("CLI to setup Fumadocs, init a config").version(package_default.version).action(async () => {
   if (await initConfig()) {
-    console.log(picocolors5.green("Initialized a `./cli.json` config file."));
+    console.log(picocolors3.green("Initialized a `./cli.json` config file."));
   } else {
-    console.log(picocolors5.redBright("A config file already exists."));
+    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 loadConfig(options.config));
-});
-program.command("init").description("init a new plugin to your docs").argument("[string]", "plugin name").action(async (str, { config }) => {
-  const loadedConfig = await loadConfig(config);
-  if (str) {
-    const plugin = str in plugins ? plugins[str] : void 0;
-    if (!plugin) throw new Error(`Plugin not found: ${str}`);
-    await init(plugin, loadedConfig);
-    return;
-  }
-  const value = await select2({
-    message: "Select components to install",
-    options: Object.keys(plugins).map((c) => ({
-      label: c,
-      value: c
-    }))
-  });
-  if (isCancel5(value)) {
-    outro4("Ended");
-    return;
-  }
-  await init(plugins[value], loadedConfig);
+  await customise(resolver, await createOrLoadConfig(options.config));
 });
 var dirShortcuts = {
   ":dev": "https://preview.fumadocs.dev/registry",
@@ -1099,7 +663,7 @@ var dirShortcuts = {
 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 loadConfig(options.config));
+    await add(input, resolver, await createOrLoadConfig(options.config));
   }
 );
 program.command("tree").argument(
@@ -1119,10 +683,10 @@ program.command("tree").argument(
     } catch {
       nodes = await runTree(str ?? "./");
     }
-    const out = js || output && jsExtensions.includes(path9.extname(output)) ? treeToJavaScript(nodes, noRoot, importName) : treeToMdx(nodes, noRoot);
+    const out = js || output && jsExtensions.includes(path4.extname(output)) ? treeToJavaScript(nodes, noRoot, importName) : treeToMdx(nodes, noRoot);
     if (output) {
-      await fs10.mkdir(path9.dirname(output), { recursive: true });
-      await fs10.writeFile(output, out);
+      await fs5.mkdir(path4.dirname(output), { recursive: true });
+      await fs5.writeFile(output, out);
     } else {
       console.log(out);
     }