create-fumadocs-app 16.0.3 → 16.0.5

package/README.md

@@ -1,6 +1,6 @@
 # Create Fumadocs App
 
-A CLI tool to create new Next.js documentation sites with Fumadocs.
+A CLI tool to create new documentation sites with Fumadocs.
 
 ```bash
 npx create-fumadocs-app

package/dist/bin.d.ts

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

package/dist/bin.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+import {
+  create,
+  getPackageManager,
+  managers
+} from "./chunk-F7NHHEKG.js";
+import {
+  isCI,
+  templates
+} from "./chunk-XPRRZX4H.js";
+
+// src/bin.ts
+import fs from "fs/promises";
+import path from "path";
+import {
+  cancel,
+  confirm,
+  group,
+  intro,
+  isCancel,
+  outro,
+  select,
+  spinner,
+  text
+} from "@clack/prompts";
+import pc from "picocolors";
+import { Option, program } from "@commander-js/extra-typings";
+var command = program.argument("[name]", "the project name").option("--src", "(Next.js only) enable `src/` directory").option("--install", "install packages automatically").option("--no-git", "disable auto Git repository initialization").addOption(
+  new Option(
+    "--linter <name>",
+    "configure a linter/formatter, ESLint is currently Next.js only."
+  ).choices(["eslint", "biome"])
+).addOption(
+  new Option("--search <name>", "configure a search solution").choices([
+    "orama",
+    "orama-cloud"
+  ])
+).addOption(
+  new Option("--template <name>", "choose a template").choices(
+    templates.map((item) => item.value)
+  )
+).addOption(
+  new Option("--pm <name>", "choose a package manager").choices(managers).default(getPackageManager())
+);
+async function main() {
+  command.parse(process.argv);
+  const defaultName = command.args[0];
+  const config = command.opts();
+  intro(pc.bgCyan(pc.bold("Create Fumadocs App")));
+  const options = await group(
+    {
+      name: async () => {
+        if (defaultName) return defaultName;
+        if (isCI) return "untitled";
+        return text({
+          message: "Project name",
+          placeholder: "my-app",
+          defaultValue: "my-app"
+        });
+      },
+      template: async () => {
+        if (config.template) return config.template;
+        if (isCI) return "+next+fuma-docs-mdx";
+        return select({
+          message: "Choose a template",
+          initialValue: "+next+fuma-docs-mdx",
+          options: templates
+        });
+      },
+      src: async ({ results }) => {
+        if (config.src !== void 0) return config.src;
+        if (isCI || !results.template?.startsWith("+next")) return false;
+        return confirm({
+          message: "Use `/src` directory?",
+          initialValue: false
+        });
+      },
+      lint: async ({ results }) => {
+        if (config.linter !== void 0) return config.linter;
+        if (isCI) return "disabled";
+        return select({
+          message: "Configure linter?",
+          options: results.template === "+next+fuma-docs-mdx" ? [
+            {
+              value: "disabled",
+              label: "Disabled"
+            },
+            {
+              value: "eslint",
+              label: "ESLint"
+            },
+            {
+              value: "biome",
+              label: "Biome"
+            }
+          ] : [
+            {
+              value: "disabled",
+              label: "Disabled"
+            },
+            {
+              value: "biome",
+              label: "Biome"
+            }
+          ]
+        });
+      },
+      search: async () => {
+        if (config.search !== void 0) return config.search;
+        if (isCI) return "orama";
+        return select({
+          message: "Choose a search solution?",
+          options: [
+            {
+              value: "orama",
+              label: "Default",
+              hint: "local search powered by Orama, recommended"
+            },
+            {
+              value: "orama-cloud",
+              label: "Orama Cloud",
+              hint: "3rd party search solution, signup needed"
+            }
+          ]
+        });
+      },
+      installDeps: async () => {
+        if (config.install !== void 0) return config.install;
+        if (isCI) return false;
+        return confirm({
+          message: `Do you want to install packages automatically? (detected as ${config.pm})`
+        });
+      }
+    },
+    {
+      onCancel: () => {
+        cancel("Installation Stopped.");
+        process.exit(0);
+      }
+    }
+  );
+  const projectName = options.name.toLowerCase().replace(/\s/, "-");
+  if (!isCI) await checkDir(projectName);
+  const info = spinner();
+  info.start(`Generating Project`);
+  const plugins = [];
+  if (options.src) {
+    const { nextUseSrc } = await import("./plugins/next-use-src.js");
+    plugins.push(nextUseSrc());
+  }
+  if (options.search === "orama-cloud") {
+    const { oramaCloud } = await import("./plugins/orama-cloud.js");
+    plugins.push(oramaCloud());
+  }
+  if (options.lint === "eslint") {
+    const { eslint } = await import("./plugins/eslint.js");
+    plugins.push(eslint());
+  }
+  if (options.lint === "biome") {
+    const { biome } = await import("./plugins/biome.js");
+    plugins.push(biome());
+  }
+  await create({
+    packageManager: config.pm,
+    template: options.template,
+    outputDir: projectName,
+    installDeps: options.installDeps,
+    initializeGit: config.git,
+    plugins,
+    log: (message) => {
+      info.message(message);
+    }
+  });
+  info.stop("Project Generated");
+  outro(pc.bgGreen(pc.bold("Done")));
+  console.log(pc.bold("\nOpen the project"));
+  console.log(pc.cyan(`cd ${projectName}`));
+  console.log(pc.bold("\nRun Development Server"));
+  if (config.pm === "npm" || config.pm === "bun") {
+    console.log(pc.cyan(`${config.pm} run dev`));
+  } else {
+    console.log(pc.cyan(`${config.pm} dev`));
+  }
+  console.log(
+    pc.bold("\nYou can now open the project and start writing documents")
+  );
+  process.exit(0);
+}
+async function checkDir(outputDir) {
+  const destDir = await fs.readdir(outputDir).catch(() => null);
+  if (!destDir || destDir.length === 0) return;
+  const del = await confirm({
+    message: `directory ${outputDir} already exists, do you want to delete its files?`
+  });
+  if (isCancel(del)) {
+    cancel();
+    process.exit(1);
+  }
+  if (!del) return;
+  const info = spinner();
+  info.start(`Deleting files in ${outputDir}`);
+  await Promise.all(
+    destDir.map((item) => {
+      return fs.rm(path.join(outputDir, item), {
+        recursive: true,
+        force: true
+      });
+    })
+  );
+  info.stop(`Deleted files in ${outputDir}`);
+}
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/dist/chunk-BEZTHMLF.js

@@ -0,0 +1,51 @@
+// src/plugins/biome.next.json
+var $schema = "https://biomejs.dev/schemas/2.2.0/schema.json";
+var vcs = {
+  enabled: true,
+  clientKind: "git",
+  useIgnoreFile: true
+};
+var files = {
+  ignoreUnknown: true,
+  includes: ["**", "!node_modules", "!.next", "!dist", "!build", "!.source"]
+};
+var formatter = {
+  enabled: true,
+  indentStyle: "space",
+  indentWidth: 2
+};
+var linter = {
+  enabled: true,
+  rules: {
+    recommended: true
+  },
+  domains: {
+    next: "recommended",
+    react: "recommended"
+  }
+};
+var assist = {
+  actions: {
+    source: {
+      organizeImports: "on"
+    }
+  }
+};
+var biome_next_default = {
+  $schema,
+  vcs,
+  files,
+  formatter,
+  linter,
+  assist
+};
+
+export {
+  $schema,
+  vcs,
+  files,
+  formatter,
+  linter,
+  assist,
+  biome_next_default
+};

package/dist/chunk-F7NHHEKG.js

@@ -0,0 +1,130 @@
+import {
+  copy,
+  depVersions,
+  sourceDir,
+  templates,
+  tryGitInit
+} from "./chunk-XPRRZX4H.js";
+
+// src/index.ts
+import path from "path";
+import fs from "fs/promises";
+
+// src/auto-install.ts
+import { x } from "tinyexec";
+var managers = ["npm", "yarn", "bun", "pnpm"];
+function getPackageManager() {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("yarn")) {
+    return "yarn";
+  }
+  if (userAgent.startsWith("pnpm")) {
+    return "pnpm";
+  }
+  if (userAgent.startsWith("bun")) {
+    return "bun";
+  }
+  return "npm";
+}
+async function autoInstall(manager, dest) {
+  await x(manager, ["install"], {
+    throwOnError: true,
+    nodeOptions: {
+      env: {
+        ...process.env,
+        NODE_ENV: "development",
+        DISABLE_OPENCOLLECTIVE: "1"
+      },
+      cwd: dest
+    }
+  });
+}
+
+// src/index.ts
+async function create(createOptions) {
+  const {
+    outputDir,
+    plugins = [],
+    packageManager = "npm",
+    initializeGit = false,
+    installDeps = false,
+    log = console.log
+  } = createOptions;
+  let template = templates.find(
+    (item) => item.value === createOptions.template
+  );
+  for (const plugin of plugins) {
+    template = await plugin.template?.call({ dest: outputDir }, template) ?? template;
+  }
+  const appDir = path.join(outputDir, template.appDir);
+  const projectName = path.basename(outputDir);
+  const pluginContext = {
+    template,
+    dest: outputDir,
+    log,
+    appDir
+  };
+  await copy(path.join(sourceDir, "template", template.value), outputDir, {
+    rename(file) {
+      file = file.replace("example.gitignore", ".gitignore");
+      return template.rename?.(file) ?? file;
+    }
+  });
+  const packageJsonPath = path.join(outputDir, "package.json");
+  let packageJson = await initPackageJson(projectName, packageJsonPath);
+  for (const plugin of plugins) {
+    packageJson = await plugin.packageJson?.call(pluginContext, packageJson) ?? packageJson;
+  }
+  await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  const readmePath = path.join(outputDir, "README.md");
+  let readme = `# ${projectName}
+
+${await fs.readFile(readmePath)}`;
+  for (const plugin of plugins) {
+    readme = await plugin.readme?.call(pluginContext, readme) ?? readme;
+  }
+  await fs.writeFile(readmePath, readme);
+  for (const plugin of plugins) {
+    await plugin.afterWrite?.call(pluginContext);
+  }
+  if (installDeps) {
+    try {
+      await autoInstall(packageManager, outputDir);
+      log("Installed dependencies");
+    } catch (err) {
+      log(`Failed to install dependencies: ${err}`);
+    }
+  }
+  if (initializeGit && await tryGitInit(outputDir)) {
+    log("Initialized Git repository");
+  }
+}
+async function initPackageJson(projectName, packageJsonPath) {
+  function replaceWorkspaceDeps(deps = {}) {
+    for (const k in deps) {
+      if (deps[k].startsWith("workspace:") && k in depVersions) {
+        deps[k] = depVersions[k];
+      }
+    }
+    return deps;
+  }
+  const packageJson = JSON.parse(
+    (await fs.readFile(packageJsonPath)).toString()
+  );
+  return {
+    ...packageJson,
+    name: projectName,
+    scripts: {
+      ...packageJson.scripts,
+      postinstall: "fumadocs-mdx"
+    },
+    dependencies: replaceWorkspaceDeps(packageJson.dependencies),
+    devDependencies: replaceWorkspaceDeps(packageJson.devDependencies)
+  };
+}
+
+export {
+  managers,
+  getPackageManager,
+  create
+};

package/dist/chunk-JCFTHRDR.js

@@ -0,0 +1,50 @@
+// src/plugins/biome.base.json
+var $schema = "https://biomejs.dev/schemas/2.2.0/schema.json";
+var vcs = {
+  enabled: true,
+  clientKind: "git",
+  useIgnoreFile: true
+};
+var files = {
+  ignoreUnknown: true,
+  includes: ["**", "!node_modules", "!.source"]
+};
+var formatter = {
+  enabled: true,
+  indentStyle: "space",
+  indentWidth: 2
+};
+var linter = {
+  enabled: true,
+  rules: {
+    recommended: true
+  },
+  domains: {
+    react: "recommended"
+  }
+};
+var assist = {
+  actions: {
+    source: {
+      organizeImports: "on"
+    }
+  }
+};
+var biome_base_default = {
+  $schema,
+  vcs,
+  files,
+  formatter,
+  linter,
+  assist
+};
+
+export {
+  $schema,
+  vcs,
+  files,
+  formatter,
+  linter,
+  assist,
+  biome_base_default
+};

package/dist/{chunk-HLHY7KAF.js → chunk-XPRRZX4H.js}

@@ -27,39 +27,39 @@ async function copy(from, to, options = {}) {
     await fs.copyFile(from, to);
   }
 }
-async function isInGitRepository(cwd2) {
+async function isInGitRepository(cwd) {
   const { exitCode } = await x("git", ["rev-parse", "--is-inside-work-tree"], {
-    nodeOptions: { cwd: cwd2 }
+    nodeOptions: { cwd }
   });
   return exitCode === 0;
 }
-async function isDefaultBranchSet(cwd2) {
+async function isDefaultBranchSet(cwd) {
   const { exitCode } = await x("git", ["config", "init.defaultBranch"], {
-    nodeOptions: { cwd: cwd2 }
+    nodeOptions: { cwd }
   });
   return exitCode === 0;
 }
-async function tryGitInit(cwd2) {
+async function tryGitInit(cwd) {
   const { exitCode } = await x("git", ["--version"]);
   if (exitCode !== 0) return false;
-  if (await isInGitRepository(cwd2)) return false;
+  if (await isInGitRepository(cwd)) return false;
   try {
     await x("git", ["init"], {
       throwOnError: true,
-      nodeOptions: { cwd: cwd2 }
+      nodeOptions: { cwd }
     });
-    if (!await isDefaultBranchSet(cwd2)) {
+    if (!await isDefaultBranchSet(cwd)) {
       await x("git", ["checkout", "-b", "main"], {
         throwOnError: true,
         nodeOptions: {
-          cwd: cwd2
+          cwd
         }
       });
     }
     await x("git", ["add", "-A"], {
       throwOnError: true,
       nodeOptions: {
-        cwd: cwd2
+        cwd
       }
     });
     await x(
@@ -68,13 +68,13 @@ async function tryGitInit(cwd2) {
       {
         throwOnError: true,
         nodeOptions: {
-          cwd: cwd2
+          cwd
         }
       }
     );
     return true;
   } catch {
-    await fs.rmdir(join(cwd2, ".git"), { recursive: true }).catch(() => null);
+    await fs.rmdir(join(cwd, ".git"), { recursive: true }).catch(() => null);
     return false;
   }
 }
@@ -91,83 +91,61 @@ function pick(obj, keys) {
 // src/constants.ts
 import { fileURLToPath } from "url";
 
-// src/versions.js
-var versions = { "fumadocs-core": "16.0.3", "fumadocs-ui": "16.0.3", "fumadocs-mdx": "13.0.1", "@fumadocs/mdx-remote": "1.4.3", "@fumadocs/content-collections": "1.2.4" };
-
 // ../create-app-versions/package.json
 var package_default = {
-  name: "example-versions",
-  version: "0.0.0",
+  name: "create-fumadocs-versions",
+  version: "16.0.5",
   private: true,
   description: "Used to track dependency versions in create-fumadocs-app",
   dependencies: {
+    eslint: "^9.38.0",
     "@biomejs/biome": "^2.2.6",
-    "@content-collections/core": "^0.11.1",
-    "@content-collections/mdx": "^0.2.2",
-    "@content-collections/next": "^0.2.8",
+    "@eslint/eslintrc": "^3.3.1",
     "@orama/core": "^1.2.13",
-    "@react-router/dev": "^7.9.4",
-    "@react-router/node": "^7.9.4",
-    "@react-router/serve": "^7.9.4",
-    "@tailwindcss/postcss": "^4.1.15",
-    "@tailwindcss/vite": "^4.1.15",
-    "@tanstack/react-router": "^1.133.21",
-    "@tanstack/react-start": "^1.133.21",
-    "@types/mdx": "^2.0.13",
-    "@types/node": "24.9.1",
-    "@types/react": "^19.2.2",
-    "@types/react-dom": "^19.2.2",
-    "@vitejs/plugin-react": "^5.0.4",
-    "gray-matter": "^4.0.3",
-    isbot: "^5.1.31",
-    "lucide-react": "^0.546.0",
-    next: "16.0.0",
-    postcss: "^8.5.6",
-    react: "^19.2.0",
-    "react-dom": "^19.2.0",
-    "react-router": "^7.9.4",
-    "react-router-devtools": "^5.1.3",
-    shiki: "^3.13.0",
-    tailwindcss: "^4.1.15",
-    tinyglobby: "^0.2.15",
-    typescript: "^5.9.3",
-    vinxi: "^0.5.8",
-    vite: "^7.1.11",
-    "vite-tsconfig-paths": "^5.1.4"
+    "fumadocs-core": "workspace:*",
+    "fumadocs-mdx": "workspace:*",
+    "fumadocs-ui": "workspace:*"
   }
 };
 
 // src/constants.ts
 var sourceDir = fileURLToPath(new URL(`../`, import.meta.url).href);
-var cwd = process.cwd();
+var isCI = Boolean(process.env.CI);
 var templates = [
   {
     value: "+next+fuma-docs-mdx",
     label: "Next.js: Fumadocs MDX",
-    hint: "recommended"
+    hint: "recommended",
+    appDir: "",
+    rootProviderPath: "app/layout.tsx"
   },
   {
     value: "waku",
-    label: "Waku: Fumadocs MDX"
+    label: "Waku: Fumadocs MDX",
+    appDir: "src",
+    rootProviderPath: "components/provider.tsx"
   },
   {
     value: "react-router",
-    label: "React Router: Fumadocs MDX (not RSC)"
+    label: "React Router: Fumadocs MDX (not RSC)",
+    appDir: "app",
+    rootProviderPath: "root.tsx"
   },
   {
     value: "react-router-spa",
     label: "React Router SPA: Fumadocs MDX (not RSC)",
-    hint: "SPA mode allows you to host the site statically, compatible with a CDN."
+    hint: "SPA mode allows you to host the site statically, compatible with a CDN.",
+    appDir: "app",
+    rootProviderPath: "root.tsx"
   },
   {
     value: "tanstack-start",
-    label: "Tanstack Start: Fumadocs MDX (not RSC)"
+    label: "Tanstack Start: Fumadocs MDX (not RSC)",
+    appDir: "src",
+    rootProviderPath: "routes/__root.tsx"
   }
 ];
-var depVersions = {
-  ...versions,
-  ...package_default.dependencies
-};
+var depVersions = package_default.dependencies;
 
 export {
   writeFile,
@@ -175,7 +153,7 @@ export {
   tryGitInit,
   pick,
   sourceDir,
-  cwd,
+  isCI,
   templates,
   depVersions
 };

package/dist/index.d.ts

@@ -1 +1,63 @@
-#!/usr/bin/env node
+type PackageManager = (typeof managers)[number];
+declare const managers: readonly ["npm", "yarn", "bun", "pnpm"];
+
+interface TemplateInfo {
+    value: '+next+fuma-docs-mdx' | 'waku' | 'react-router' | 'react-router-spa' | 'tanstack-start';
+    label: string;
+    appDir: string;
+    /**
+     * path to root provider, relative to `appDir``
+     */
+    rootProviderPath: string;
+    hint?: string;
+    /**
+     * rename files when copying from template
+     */
+    rename?: (name: string) => string;
+}
+
+type Template = TemplateInfo['value'];
+interface Options {
+    outputDir: string;
+    template: Template;
+    /**
+     * the package manager to use
+     *
+     * @defaultValue 'npm'
+     */
+    packageManager?: PackageManager;
+    installDeps?: boolean;
+    initializeGit?: boolean;
+    log?: (message: string) => void;
+    plugins?: TemplatePlugin[];
+}
+interface TemplatePluginContext {
+    template: TemplateInfo;
+    log: (message: string) => void;
+    /**
+     * output directory
+     */
+    dest: string;
+    /**
+     * output directory for app code (e.g. under `/src`)
+     */
+    appDir: string;
+}
+type PackageJsonType = {
+    name?: string;
+    version?: string;
+    private?: boolean;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+} & Record<string, unknown>;
+type Awaitable<T> = T | Promise<T>;
+interface TemplatePlugin {
+    template?: (this: Pick<TemplatePluginContext, 'dest'>, info: TemplateInfo) => Awaitable<void | TemplateInfo>;
+    packageJson?: (this: TemplatePluginContext, packageJson: PackageJsonType) => Awaitable<void | PackageJsonType>;
+    afterWrite?: (this: TemplatePluginContext) => Awaitable<void>;
+    readme?: (this: TemplatePluginContext, content: string) => Awaitable<void | string>;
+}
+declare function create(createOptions: Options): Promise<void>;
+
+export { type Options, type PackageJsonType, type Template, type TemplatePlugin, type TemplatePluginContext, create };