@fumadocs/cli 0.0.7 → 0.1.0

package/dist/build/index.d.ts

@@ -1,7 +1,12 @@
+import * as ts_morph from 'ts-morph';
+
 interface Component {
     name: string;
     description?: string;
-    files: string[];
+    files: (string | {
+        in: string;
+        out: string;
+    })[];
     /**
      * Don't list the component in registry index file
      */
@@ -11,9 +16,12 @@ interface Component {
      */
     mapImportPath?: Record<string, string | {
         type: 'component';
-        registry: string;
         name: string;
         file: string;
+        /**
+         * Registry of the component, refer to the current registry if not specified
+         */
+        registry?: string;
     }>;
 }
 type NamespaceType = 'components' | 'hooks' | 'lib';
@@ -23,9 +31,9 @@ interface PackageJson {
 }
 interface Registry {
     /**
-     * The path of registry, needed to resolve relative paths
+     * The directory of registry, needed to resolve relative paths
      */
-    path: string;
+    dir: string;
     /**
      * Extend on existing registry
      */
@@ -78,23 +86,31 @@ interface DependencyInfo {
     type: 'runtime' | 'dev';
     version?: string;
 }
-interface ComponentBuilder {
-    registryDir: string;
-    resolveDep: (specifier: string) => DependencyInfo & {
-        name: string;
-    };
-    resolveOutputPath: (path: string, namespace?: string) => string;
-    getSubComponent: (path: string) => {
-        component: Component;
-    } | undefined;
-}
+type GetComponentResult = {
+    type: 'local';
+    registryName?: string;
+    component: Component;
+} | {
+    type: 'remote';
+    registryName: string;
+    component: OutputComponent;
+};
+type ComponentBuilder = ReturnType<typeof createComponentBuilder>;
 /**
  * @param registry registry object
  * @param packageJson parsed package json object
- * @param registryDir directory of registry config file
- * @param sourceDir source directory of project (e.g. `/src`), used to resolve the output paths of component files
  */
-declare function createComponentBuilder(registry: Registry, packageJson: PackageJson | undefined, registryDir: string, sourceDir: string): ComponentBuilder;
+declare function createComponentBuilder(registry: Registry, packageJson: PackageJson | undefined): {
+    registryDir: string;
+    registry: Registry;
+    resolveDep(specifier: string): DependencyInfo & {
+        name: string;
+    };
+    createSourceFile(file: string): Promise<ts_morph.SourceFile>;
+    getComponentByName(name: string, registryName?: string): GetComponentResult | undefined;
+    resolveOutputPath(file: string, registryName?: string, namespace?: string): string;
+    getSubComponent(file: string): Component | undefined;
+};
 
 declare function writeOutput(dir: string, out: Output, options?: {
     /**

package/dist/build/index.js

@@ -3,29 +3,21 @@ import {
 } from "../chunk-WBCEM7RC.js";
 
 // src/build/index.ts
-import * as fs2 from "node:fs/promises";
+import * as fs3 from "node:fs/promises";
 import * as path4 from "node:path";
 import picocolors from "picocolors";
 
 // src/build/build-registry.ts
-import * as fs from "node:fs/promises";
+import * as fs2 from "node:fs/promises";
 import * as path3 from "node:path";
-import { Project } from "ts-morph";
 
 // src/build/build-file.ts
 import * as path from "node:path";
-async function buildFile(filePath, sourceFile, builder, comp, processedFiles) {
-  processedFiles.add(filePath);
+async function buildFile(inputPath, outputPath, builder, comp, onReference) {
   const out = {
     imports: {},
     content: "",
-    path: filePath
-  };
-  const processed = {
-    files: [out],
-    dependencies: /* @__PURE__ */ new Map(),
-    devDependencies: /* @__PURE__ */ new Map(),
-    subComponents: /* @__PURE__ */ new Set()
+    path: outputPath
   };
   async function process2(specifier, getSpecifiedFile) {
     let specifiedFile = getSpecifiedFile();
@@ -38,43 +30,55 @@ async function buildFile(filePath, sourceFile, builder, comp, processedFiles) {
         specifiedFile = getSpecifiedFile();
         if (!specifiedFile) return;
       } else {
-        processed.subComponents.add(resolver.name);
-        out.imports[specifier.getLiteralValue()] = resolver.file;
+        const sub2 = builder.getComponentByName(
+          resolver.name,
+          resolver.registry
+        );
+        if (!sub2)
+          throw new Error(`Failed to resolve sub component ${resolver.name}`);
+        const value2 = onReference({
+          type: "sub-component",
+          resolved: sub2,
+          targetFile: resolver.file
+        });
+        if (value2) out.imports[specifier.getLiteralValue()] = value2;
         return;
       }
     }
     if (specifiedFile.isInNodeModules() || specifiedFile.isDeclarationFile()) {
       const info = builder.resolveDep(specifier.getLiteralValue());
-      if (info.type === "dev") {
-        processed.devDependencies.set(info.name, info.version ?? "");
-      } else {
-        processed.dependencies.set(info.name, info.version ?? "");
-      }
+      const value2 = onReference({
+        type: "dependency",
+        name: info.name,
+        version: info.version ?? "",
+        isDev: info.type === "dev"
+      });
+      if (value2) out.imports[specifier.getLiteralValue()] = value2;
       return;
     }
     const sub = builder.getSubComponent(specifiedFile.getFilePath());
     if (sub) {
-      processed.subComponents.add(sub.component.name);
-      out.imports[specifier.getLiteralValue()] = builder.resolveOutputPath(
-        specifiedFile.getFilePath()
-      );
+      const value2 = onReference({
+        type: "sub-component",
+        resolved: {
+          type: "local",
+          component: sub
+        },
+        targetFile: path.relative(
+          builder.registryDir,
+          specifiedFile.getFilePath()
+        )
+      });
+      if (value2) out.imports[specifier.getLiteralValue()] = value2;
       return;
     }
-    const referenceOutputPath = builder.resolveOutputPath(
-      specifiedFile.getFilePath()
-    );
-    if (!processedFiles.has(referenceOutputPath)) {
-      const outFile = await buildFile(
-        referenceOutputPath,
-        specifiedFile,
-        builder,
-        comp,
-        processedFiles
-      );
-      merge(processed, outFile);
-    }
-    out.imports[specifier.getLiteralValue()] = referenceOutputPath;
+    const value = onReference({
+      type: "file",
+      file: specifiedFile.getFilePath()
+    });
+    if (value) out.imports[specifier.getLiteralValue()] = value;
   }
+  const sourceFile = await builder.createSourceFile(inputPath);
   for (const item of sourceFile.getImportDeclarations()) {
     await process2(
       item.getModuleSpecifier(),
@@ -87,34 +91,32 @@ async function buildFile(filePath, sourceFile, builder, comp, processedFiles) {
     await process2(specifier, () => item.getModuleSpecifierSourceFile());
   }
   out.content = sourceFile.getFullText();
-  return processed;
-}
-function merge(to, from) {
-  to.files.push(...from.files);
-  for (const [k, v] of from.dependencies.entries()) {
-    to.dependencies.set(k, v);
-  }
-  for (const [k, v] of from.devDependencies.entries()) {
-    to.devDependencies.set(k, v);
-  }
-  from.subComponents.forEach((item) => to.subComponents.add(item));
+  return out;
 }
 
 // src/build/component-builder.ts
 import path2 from "node:path";
-function createComponentBuilder(registry, packageJson, registryDir, sourceDir) {
+import { Project } from "ts-morph";
+import * as fs from "fs/promises";
+function createComponentBuilder(registry, packageJson) {
+  const rootDir = path2.join(registry.dir, registry.rootDir);
+  const project = new Project({
+    tsConfigFilePath: registry.tsconfigPath ? path2.join(rootDir, registry.tsconfigPath) : path2.join(rootDir, "tsconfig.json")
+  });
   const fileToComponent = /* @__PURE__ */ new Map();
   for (const comp of registry.components) {
     for (const file of comp.files) {
-      if (fileToComponent.has(file))
+      const filePath = typeof file === "string" ? file : file.in;
+      if (fileToComponent.has(filePath))
         console.warn(
           `the same file ${file} exists in multiple component, you should make the shared file a separate component.`
         );
-      fileToComponent.set(file, comp);
+      fileToComponent.set(filePath, comp);
     }
   }
   return {
-    registryDir,
+    registryDir: registry.dir,
+    registry,
     resolveDep(specifier) {
       const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
       if (registry.dependencies && name in registry.dependencies)
@@ -138,64 +140,89 @@ function createComponentBuilder(registry, packageJson, registryDir, sourceDir) {
       }
       return { type: "runtime", name };
     },
-    resolveOutputPath(file, forcedNamespace) {
-      const relativeFile = path2.relative(registryDir, file);
-      if (forcedNamespace) {
-        return `${forcedNamespace}:${path2.relative(sourceDir, file)}`;
+    async createSourceFile(file) {
+      const content = await fs.readFile(file);
+      return project.createSourceFile(file, content.toString(), {
+        overwrite: true
+      });
+    },
+    getComponentByName(name, registryName) {
+      if (registryName) {
+        const child = registry.on[registryName];
+        const comp2 = child.registry.components.find(
+          (comp3) => comp3.name === name
+        );
+        if (comp2) {
+          return {
+            type: child.type,
+            registryName,
+            component: comp2
+          };
+        }
+        return;
+      }
+      const comp = registry.components.find((comp2) => comp2.name === name);
+      if (comp) {
+        return {
+          type: "local",
+          registryName,
+          component: comp
+        };
+      }
+    },
+    resolveOutputPath(file, registryName, namespace) {
+      let targetRegistry = registry;
+      if (registryName && registry.on[registryName].type === "local") {
+        targetRegistry = registry.on[registryName].registry;
+      }
+      const parsed = file.split(":", 2);
+      if (parsed.length > 1) {
+        namespace ??= parsed[0];
+        file = parsed[1];
       }
-      if (registry.namespaces)
-        for (const namespace of Object.keys(registry.namespaces)) {
-          const relativePath = path2.relative(namespace, relativeFile);
-          if (!relativePath.startsWith("../") && !path2.isAbsolute(relativePath)) {
-            return `${registry.namespaces[namespace]}:${relativePath}`;
+      if (!path2.isAbsolute(file)) {
+        file = path2.join(targetRegistry.dir, file);
+      }
+      const rootDir2 = path2.join(targetRegistry.dir, targetRegistry.rootDir);
+      if (namespace) {
+        return `${namespace}:${path2.relative(rootDir2, file)}`;
+      }
+      if (targetRegistry.namespaces)
+        for (const namespace2 in targetRegistry.namespaces) {
+          const relativePath = path2.relative(
+            path2.join(targetRegistry.dir, namespace2),
+            file
+          );
+          if (!relativePath.startsWith("../")) {
+            return `${targetRegistry.namespaces[namespace2]}:${relativePath}`;
           }
         }
-      return path2.relative(sourceDir, file);
+      return path2.relative(rootDir2, file);
     },
     getSubComponent(file) {
-      const relativeFile = path2.relative(registryDir, file);
+      const relativeFile = path2.relative(registry.dir, file);
       const comp = fileToComponent.get(relativeFile);
       if (!comp) return;
-      return {
-        component: comp
-      };
+      return comp;
     }
   };
 }
 
-// src/build/get-path-namespace.ts
-function getFileNamespace(file) {
-  const parsed = file.split(":", 2);
-  if (parsed.length > 1) return { namespace: parsed[0], path: parsed[1] };
-  return { path: file };
-}
-
 // src/build/build-registry.ts
 async function build(registry) {
-  const registryDir = path3.dirname(registry.path);
-  const rootDir = path3.join(registryDir, registry.rootDir);
-  const useSrc = await exists(path3.join(rootDir, "src"));
   const output = {
     index: [],
     components: []
   };
-  const project = new Project({
-    tsConfigFilePath: registry.tsconfigPath ? path3.join(registryDir, registry.tsconfigPath) : path3.join(rootDir, "tsconfig.json")
-  });
   function readPackageJson() {
     if (typeof registry.packageJson !== "string" && registry.packageJson)
       return registry.packageJson;
-    return fs.readFile(
-      registry.packageJson ? path3.join(registryDir, registry.packageJson) : path3.join(rootDir, "package.json")
+    return fs2.readFile(
+      registry.packageJson ? path3.join(registry.dir, registry.packageJson) : path3.join(registry.dir, registry.rootDir, "package.json")
     ).then((res) => JSON.parse(res.toString())).catch(() => void 0);
   }
   const packageJson = await readPackageJson();
-  const builder = createComponentBuilder(
-    registry,
-    packageJson,
-    registryDir,
-    useSrc ? path3.join(rootDir, "src") : rootDir
-  );
+  const builder = createComponentBuilder(registry, packageJson);
   const buildExtendRegistries = Object.values(registry.on ?? {}).map(
     async (schema) => {
       if (schema.type === "remote") {
@@ -208,55 +235,10 @@ async function build(registry) {
     output.components.push(...built.components);
     output.index.push(...built.index);
   }
-  const buildComps = registry.components.map(async (component) => {
-    const processedFiles = /* @__PURE__ */ new Set();
-    const collect = {
-      files: [],
-      subComponents: /* @__PURE__ */ new Set(),
-      devDependencies: /* @__PURE__ */ new Map(),
-      dependencies: /* @__PURE__ */ new Map()
-    };
-    const read = component.files.map(async (sourcePath) => {
-      const parsed = getFileNamespace(sourcePath);
-      parsed.path = path3.join(registryDir, parsed.path);
-      const content = await fs.readFile(parsed.path);
-      const sourceFile = project.createSourceFile(
-        parsed.path,
-        content.toString(),
-        {
-          overwrite: true
-        }
-      );
-      const outputPath = builder.resolveOutputPath(
-        parsed.path,
-        parsed.namespace
-      );
-      if (processedFiles.has(outputPath)) return;
-      return buildFile(
-        outputPath,
-        sourceFile,
-        builder,
-        component,
-        processedFiles
-      );
-    });
-    const outFiles = await Promise.all(read);
-    for (const file of outFiles) {
-      if (!file) continue;
-      merge(collect, file);
-    }
-    return [
-      component,
-      {
-        name: component.name,
-        files: collect.files,
-        subComponents: Array.from(collect.subComponents),
-        dependencies: Object.fromEntries(collect.dependencies),
-        devDependencies: Object.fromEntries(collect.devDependencies)
-      }
-    ];
-  });
-  for (const [input, comp] of await Promise.all(buildComps)) {
+  const builtComps = await Promise.all(
+    registry.components.map((component) => buildComponent(component, builder))
+  );
+  for (const [input, comp] of builtComps) {
     if (!input.unlisted) {
       output.index.push({
         name: input.name,
@@ -267,12 +249,92 @@ async function build(registry) {
   }
   return output;
 }
+async function buildComponent(component, builder) {
+  const processedFiles = /* @__PURE__ */ new Set();
+  const subComponents = /* @__PURE__ */ new Set();
+  const devDependencies = /* @__PURE__ */ new Map();
+  const dependencies = /* @__PURE__ */ new Map();
+  const files = [];
+  async function build2(file) {
+    let inputPath;
+    let outputPath;
+    if (typeof file === "string") {
+      let namespace;
+      const parsed = file.split(":", 2);
+      if (parsed.length > 1) {
+        namespace = parsed[0];
+        inputPath = path3.join(builder.registryDir, parsed[1]);
+      } else {
+        inputPath = path3.join(builder.registryDir, file);
+      }
+      outputPath = builder.resolveOutputPath(file, void 0, namespace);
+    } else {
+      inputPath = path3.join(builder.registryDir, file.in);
+      outputPath = file.out;
+    }
+    if (processedFiles.has(inputPath)) return;
+    processedFiles.add(inputPath);
+    const queue = [];
+    files.push(
+      await buildFile(
+        inputPath,
+        outputPath,
+        builder,
+        component,
+        (reference) => {
+          if (reference.type === "file") {
+            queue.push(path3.relative(builder.registryDir, reference.file));
+            return builder.resolveOutputPath(reference.file);
+          }
+          if (reference.type === "sub-component") {
+            const resolved = reference.resolved;
+            subComponents.add(resolved.component.name);
+            if (resolved.type === "remote") {
+              return reference.targetFile;
+            }
+            for (const childFile of resolved.component.files) {
+              if (typeof childFile === "string" && childFile === reference.targetFile) {
+                return builder.resolveOutputPath(
+                  childFile,
+                  reference.resolved.registryName
+                );
+              }
+              if (typeof childFile === "object" && childFile.in === reference.targetFile) {
+                return childFile.out;
+              }
+            }
+            throw new Error(
+              `Failed to find sub component ${resolved.component.name}'s ${reference.targetFile} referenced by ${inputPath}`
+            );
+          }
+          if (reference.type === "dependency") {
+            if (reference.isDev)
+              devDependencies.set(reference.name, reference.version);
+            else dependencies.set(reference.name, reference.version);
+          }
+        }
+      )
+    );
+    await Promise.all(queue.map(build2));
+  }
+  await Promise.all(component.files.map(build2));
+  return [
+    component,
+    {
+      name: component.name,
+      files,
+      subComponents: Array.from(subComponents),
+      dependencies: Object.fromEntries(dependencies),
+      devDependencies: Object.fromEntries(devDependencies)
+    }
+  ];
+}
 
 // src/build/index.ts
 async function writeOutput(dir, out, options = {}) {
   const { log = true } = options;
   if (options.cleanDir && await exists(dir)) {
-    await fs2.rm(dir, {
+    await fs3.rm(dir, {
       recursive: true
     });
     if (log) {
@@ -281,8 +343,8 @@ async function writeOutput(dir, out, options = {}) {
   }
   async function writeFile2(file, content) {
     if (!log) return;
-    await fs2.mkdir(path4.dirname(file), { recursive: true });
-    await fs2.writeFile(file, content);
+    await fs3.mkdir(path4.dirname(file), { recursive: true });
+    await fs3.writeFile(file, content);
     const size = (Buffer.byteLength(content) / 1024).toFixed(2);
     console.log(
       `${picocolors.greenBright("+")} ${path4.relative(process.cwd(), file)} ${picocolors.dim(`${size.toString()} KB`)}`

package/dist/index.js

@@ -8,13 +8,13 @@ import {
 import fs10 from "node:fs/promises";
 import path9 from "node:path";
 import { Command } from "commander";
-import picocolors5 from "picocolors";
+import picocolors6 from "picocolors";
 import {
   isCancel as isCancel3,
-  log as log5,
+  log as log6,
   multiselect,
   outro as outro2,
-  select,
+  select as select2,
   spinner as spinner3
 } from "@clack/prompts";
 
@@ -238,7 +238,7 @@ async function init(plugin, config = {}) {
     if (value) {
       await plugin.transform(ctx);
       note(
-        `You can format the output with Prettier or other code formating tools
+        `You can format the output with Prettier or other code formatting tools
 prettier . --write`,
         picocolors.bold(picocolors.green("Changes Applied"))
       );
@@ -510,6 +510,10 @@ import fs5 from "node:fs/promises";
 import path5 from "node: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 fs5.lstat(from).catch(() => void 0);
   if (!stats) return;
   if (stats.isDirectory()) {
@@ -517,8 +521,8 @@ async function moveFiles(from, to, filter, project, src2, originalDir = from) {
     await Promise.all(
       items.map(async (item) => {
         await moveFiles(
-          path5.resolve(from, item),
-          path5.resolve(to, item),
+          path5.join(from, item),
+          path5.join(to, item),
           filter,
           project,
           src2,
@@ -529,31 +533,31 @@ async function moveFiles(from, to, filter, project, src2, originalDir = from) {
     await fs5.rmdir(from).catch(() => {
     });
   }
-  if (!stats.isFile()) return;
-  const allowed = await filter(path5.resolve(from));
-  if (!allowed) return;
-  if (transformExtensions.includes(path5.extname(from))) {
-    const content = await fs5.readFile(from);
-    const sourceFile = project.createSourceFile(from, content.toString(), {
-      overwrite: true
-    });
-    await transformReferences(
-      sourceFile,
-      {
-        alias: {
-          type: "append",
-          dir: src2 ? "src" : ""
-        },
-        relativeTo: path5.dirname(from)
+  if (!stats.isFile() || !await isIncluded(from)) return;
+  const content = await fs5.readFile(from);
+  const sourceFile = project.createSourceFile(from, content.toString(), {
+    overwrite: true
+  });
+  await transformReferences(
+    sourceFile,
+    {
+      alias: {
+        type: "append",
+        dir: src2 ? "src" : ""
       },
-      (resolved) => {
-        if (resolved.type !== "file") return;
-        if (isRelative(originalDir, from) && filter(resolved.path)) return;
-        return toReferencePath(to, resolved.path);
-      }
-    );
-    await sourceFile.save();
-  }
+      relativeTo: path5.dirname(from)
+    },
+    async (resolved) => {
+      if (resolved.type !== "file") return;
+      if (
+        // ignore if the file is also moved
+        isRelative(originalDir, from) && await isIncluded(resolved.path)
+      )
+        return;
+      return toReferencePath(to, resolved.path);
+    }
+  );
+  await sourceFile.save();
   await fs5.mkdir(path5.dirname(to), { recursive: true });
   await fs5.rename(from, to);
 }
@@ -707,7 +711,9 @@ export default async function Page({
       resolveAppPath("./app", ctx.src),
       resolveAppPath("./app/[lang]", ctx.src),
       (v) => {
-        return path7.basename(v, path7.extname(v)) !== "layout.config" && !isRelative("./app/api", v);
+        const parsed = path7.parse(v);
+        if (parsed.ext === ".css") return false;
+        return parsed.name !== "layout.config" && !isRelative("./app/api", v);
       },
       project,
       ctx.src
@@ -902,7 +908,7 @@ async function runTree(args) {
 // package.json
 var package_default = {
   name: "@fumadocs/cli",
-  version: "0.0.7",
+  version: "0.1.0",
   description: "The CLI tool for Fumadocs",
   keywords: [
     "NextJs",
@@ -936,35 +942,121 @@ var package_default = {
     "types:check": "tsc --noEmit"
   },
   dependencies: {
-    "@clack/prompts": "^0.9.1",
-    commander: "^13.0.0",
+    "@clack/prompts": "^0.10.0",
+    commander: "^13.1.0",
     execa: "^9.5.2",
-    "package-manager-detector": "^0.2.8",
+    "package-manager-detector": "^1.1.0",
     picocolors: "^1.1.1",
-    "ts-morph": "^25.0.0"
+    "ts-morph": "^25.0.1"
   },
   devDependencies: {
     "@types/cross-spawn": "^6.0.6",
-    "@types/node": "22.10.6",
-    "@types/react": "^19.0.7",
+    "@types/node": "22.13.16",
+    "@types/react": "^19.0.12",
     "eslint-config-custom": "workspace:*",
     "fast-glob": "^3.3.3",
     tsconfig: "workspace:*",
-    tsx: "^4.19.2"
+    tsx: "^4.19.3"
   },
   publishConfig: {
     access: "public"
   }
 };
 
+// src/commands/customise.ts
+import { cancel as cancel2, group, intro as intro3, select, confirm as confirm3, log as log5 } from "@clack/prompts";
+import picocolors5 from "picocolors";
+async function customise(resolver, config) {
+  intro3(picocolors5.bgBlack(picocolors5.whiteBright("Customise Fumadocs UI")));
+  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"
+          }
+        ]
+      }),
+      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."
+            }
+          ]
+        });
+      },
+      page: async (v) => {
+        if (v.results.target !== "docs" || v.results.mode === "minimal")
+          return false;
+        return confirm3({
+          message: "Do you want to customise the page component too?"
+        });
+      }
+    },
+    {
+      onCancel: () => {
+        cancel2("Installation Stopped.");
+        process.exit(0);
+      }
+    }
+  );
+  if (result.target === "docs" && result.mode) {
+    if (result.page) await add("layouts/page", resolver, config);
+    if (result.mode === "minimal") {
+      await add("layouts/docs-min", resolver, config);
+    } else {
+      await add(
+        result.mode === "full-default" ? "layouts/docs" : "layouts/notebook",
+        resolver,
+        config
+      );
+    }
+    log5.info(
+      [
+        picocolors5.bold("What is Next?"),
+        "You can check the installed components in `components/layouts`.",
+        picocolors5.dim("---"),
+        "Open your `layout.tsx` files, replace the imports of components:",
+        picocolors5.greenBright(
+          "`fumadocs-ui/layouts/docs` -> `@/components/layouts/docs`"
+        ),
+        result.page || result.mode === "minimal" ? picocolors5.greenBright(
+          "`fumadocs-ui/page` -> `@/components/layouts/page`"
+        ) : ""
+      ].join("\n")
+    );
+  }
+}
+
 // src/index.ts
-var program = new Command();
-program.name("fumadocs").description("CLI to setup Fumadocs").version(package_default.version);
-program.command("config").description("init a config for Fumadocs CLI").action(async () => {
+var program = new Command().option("--config <string>");
+program.name("fumadocs").description("CLI to setup Fumadocs, init a config ").version(package_default.version).action(async () => {
   await initConfig();
-  console.log(picocolors5.green("Successful: ./cli.json"));
+  console.log(picocolors6.green("Initialized a `./cli.json` config file."));
 });
-program.command("init").description("init a new plugin to your docs").argument("[string]", "plugin name").option("--config <string>").action(async (str, { config }) => {
+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;
@@ -972,7 +1064,7 @@ program.command("init").description("init a new plugin to your docs").argument("
     await init(plugin, loadedConfig);
     return;
   }
-  const value = await select({
+  const value = await select2({
     message: "Select components to install",
     options: Object.keys(plugins).map((c) => ({
       label: c,
@@ -988,19 +1080,19 @@ program.command("init").description("init a new plugin to your docs").argument("
 var dirShortcuts = {
   ":dev": "https://fumadocs-dev.vercel.app/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").option("--config <string>").action(
+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) => {
-    let dir = options.dir ?? "https://fumadocs.vercel.app/registry";
-    if (dir in dirShortcuts) dir = dirShortcuts[dir];
-    const resolver = dir.startsWith("http://") || dir.startsWith("https://") ? remoteResolver(dir) : localResolver(dir);
+    const resolver = getResolverFromDir(options.dir);
     let target = input;
     if (input.length === 0) {
       const spin = spinner3();
       spin.start("fetching registry");
       const registry = await resolver("_registry.json");
-      spin.stop(picocolors5.bold(picocolors5.greenBright("registry fetched")));
+      spin.stop(picocolors6.bold(picocolors6.greenBright("registry fetched")));
       if (!registry) {
-        log5.error(`Failed to fetch '_registry.json' file from ${dir}`);
+        log6.error(
+          `Failed to fetch '_registry.json' file from ${options.dir ?? "registry"}`
+        );
         throw new Error(`Failed to fetch registry`);
       }
       const value = await multiselect({
@@ -1049,4 +1141,8 @@ program.command("tree").argument(
     }
   }
 );
+function getResolverFromDir(dir = "https://fumadocs.vercel.app/registry") {
+  if (dir in dirShortcuts) dir = dirShortcuts[dir];
+  return dir.startsWith("http://") || dir.startsWith("https://") ? remoteResolver(dir) : localResolver(dir);
+}
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fumadocs/cli",
-  "version": "0.0.7",
+  "version": "0.1.0",
   "description": "The CLI tool for Fumadocs",
   "keywords": [
     "NextJs",
@@ -26,19 +26,19 @@
     "dist/*"
   ],
   "dependencies": {
-    "@clack/prompts": "^0.9.1",
-    "commander": "^13.0.0",
+    "@clack/prompts": "^0.10.0",
+    "commander": "^13.1.0",
     "execa": "^9.5.2",
-    "package-manager-detector": "^0.2.8",
+    "package-manager-detector": "^1.1.0",
     "picocolors": "^1.1.1",
-    "ts-morph": "^25.0.0"
+    "ts-morph": "^25.0.1"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",
-    "@types/node": "22.10.6",
-    "@types/react": "^19.0.7",
+    "@types/node": "22.13.16",
+    "@types/react": "^19.0.12",
     "fast-glob": "^3.3.3",
-    "tsx": "^4.19.2",
+    "tsx": "^4.19.3",
     "eslint-config-custom": "0.0.0",
     "tsconfig": "0.0.0"
   },