@fumadocs/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,1044 @@
+#!/usr/bin/env node
+import {
+  exists,
+  isRelative
+} from "./chunk-WBCEM7RC.js";
+
+// src/index.ts
+import fs10 from "node:fs/promises";
+import path9 from "node:path";
+import { Command } from "commander";
+import picocolors5 from "picocolors";
+import {
+  isCancel as isCancel3,
+  log as log5,
+  multiselect,
+  outro as outro2,
+  select,
+  spinner as spinner3
+} from "@clack/prompts";
+
+// src/commands/init.ts
+import * as process2 from "node:process";
+import path3 from "node:path";
+import {
+  intro,
+  confirm,
+  isCancel,
+  cancel,
+  spinner,
+  log,
+  note
+} from "@clack/prompts";
+import picocolors from "picocolors";
+import { execa } from "execa";
+
+// 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 "node:path";
+async function isSrc() {
+  return exists("./src");
+}
+function resolveAppPath(filePath, src2) {
+  return src2 ? path.join("./src", filePath) : filePath;
+}
+
+// src/utils/transform-references.ts
+import path2 from "node:path";
+
+// src/config.ts
+import fs from "node: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") {
+  await fs.writeFile(file, JSON.stringify(defaultConfig, null, 2));
+}
+
+// src/constants.ts
+var typescriptExtensions = [".ts", ".tsx", ".js", ".jsx"];
+
+// src/utils/transform-references.ts
+function getOutputPath(ref, config) {
+  if (path2.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 path2.join(
+      config.aliases?.componentsDir ?? defaultConfig.aliases.componentsDir,
+      path2.relative("components", ref)
+    );
+  }
+  if (ref.startsWith("lib") || ref.startsWith("utils")) {
+    return path2.join(
+      config.aliases?.libDir ?? defaultConfig.aliases.libDir,
+      path2.relative("lib", ref)
+    );
+  }
+  return ref;
+}
+async function transformReferences(file, resolver, transform) {
+  for (const item of file.getImportDeclarations()) {
+    const ref = item.getModuleSpecifier().getLiteralValue();
+    const result = await transform(resolveReference(ref, resolver), ref);
+    if (!result) continue;
+    item.getModuleSpecifier().setLiteralValue(result);
+  }
+  for (const item of file.getExportDeclarations()) {
+    const specifier = item.getModuleSpecifier();
+    if (!specifier) continue;
+    const ref = specifier.getLiteralValue();
+    const result = await transform(resolveReference(ref, resolver), ref);
+    if (!result) continue;
+    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
+      )
+    )
+  );
+  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/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);
+  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);
+      }
+      if (!value) continue;
+    }
+    const sourceFile = project.createSourceFile(file, content, {
+      overwrite: true
+    });
+    await transformReferences(
+      sourceFile,
+      {
+        alias: {
+          type: "append",
+          dir: ctx.src ? "src" : ""
+        },
+        relativeTo: path3.dirname(file)
+      },
+      (resolved) => {
+        if (resolved.type !== "file") return;
+        return toReferencePath(file, getOutputPath(resolved.path, ctx));
+      }
+    );
+    await sourceFile.save();
+  }
+  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 execa(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 formating tools
+prettier . --write`,
+        picocolors.bold(picocolors.green("Changes Applied"))
+      );
+    } 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"
+      });
+    }
+    if (text.type === "code") {
+      note(text.code, text.title);
+    }
+  }
+}
+
+// src/commands/add.ts
+import path4 from "node:path";
+import fs3 from "node:fs/promises";
+import { log as log2, confirm as confirm2, isCancel as isCancel2, outro, spinner as spinner2, intro as intro2 } from "@clack/prompts";
+import picocolors2 from "picocolors";
+import { execa as execa2 } from "execa";
+
+// src/utils/add/get-dependencies.ts
+import fs2 from "node:fs/promises";
+async function getDependencies() {
+  const dependencies = /* @__PURE__ */ new Map();
+  if (!await exists("package.json")) return dependencies;
+  const content = await fs2.readFile("package.json");
+  const parsed = JSON.parse(content.toString());
+  if ("dependencies" in parsed && typeof parsed.dependencies === "object") {
+    const records = parsed.dependencies;
+    Object.entries(records).forEach(([k, v]) => {
+      dependencies.set(k, v);
+    });
+  }
+  if ("devDependencies" in parsed && typeof parsed.devDependencies === "object") {
+    const records = parsed.devDependencies;
+    Object.entries(records).forEach(([k, v]) => {
+      dependencies.set(k, v);
+    });
+  }
+  return dependencies;
+}
+
+// src/commands/add.ts
+var downloadedFiles = /* @__PURE__ */ new Set();
+async function add(name, resolver, config = {}) {
+  intro2(
+    picocolors2.bold(
+      picocolors2.inverse(picocolors2.cyanBright(`Add Component: ${name}`))
+    )
+  );
+  const project = createEmptyProject();
+  const result = await downloadComponent(name, {
+    project,
+    config,
+    resolver
+  });
+  if (!result) {
+    log2.error(`Component: ${name} not found`);
+    process.exit(0);
+  }
+  const installed = await getDependencies();
+  const deps = Object.entries(result.dependencies).filter(([k]) => !installed.has(k)).map(([k, v]) => v.length === 0 ? k : `${k}@${v}`);
+  const devDeps = Object.entries(result.devDependencies).filter(([k]) => !installed.has(k)).map(([k, v]) => v.length === 0 ? k : `${k}@${v}`);
+  if (deps.length > 0 || devDeps.length > 0) {
+    const manager = await getPackageManager();
+    const value = await confirm2({
+      message: `This component requires dependencies (${[...deps, ...devDeps].join(" ")}), install them with ${manager}?`
+    });
+    if (isCancel2(value)) {
+      outro(picocolors2.bold(picocolors2.greenBright("Component downloaded")));
+      process.exit(0);
+    }
+    if (value) {
+      const spin = spinner2();
+      spin.start("Installing dependencies...");
+      if (deps.length > 0) await execa2(manager, ["install", ...deps]);
+      if (devDeps.length > 0)
+        await execa2(manager, ["install", ...devDeps, "-D"]);
+      spin.stop("Dependencies installed.");
+    }
+  }
+  outro(picocolors2.bold(picocolors2.greenBright("Component installed")));
+}
+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 fs3.readFile(outPath).then((res) => res.toString() !== output).catch(() => false);
+    if (requireOverride) {
+      const value = await confirm2({
+        message: `Do you want to override ${outPath}?`
+      });
+      if (isCancel2(value)) {
+        outro("Ended");
+        process.exit(0);
+      }
+      canWrite = value;
+    }
+    if (canWrite) {
+      await fs3.mkdir(path4.dirname(outPath), { recursive: true });
+      await fs3.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
+  });
+  for (const item of sourceFile.getImportDeclarations()) {
+    const ref = item.getModuleSpecifier().getLiteralValue();
+    if (ref in file.imports) {
+      const outputPath = resolveOutputPath(file.imports[ref], ctx.config);
+      item.getModuleSpecifier().setLiteralValue(toReferencePath(filePath, outputPath));
+    }
+  }
+  for (const item of sourceFile.getExportDeclarations()) {
+    const specifier = item.getModuleSpecifier();
+    if (!specifier) continue;
+    const ref = specifier.getLiteralValue();
+    if (ref in file.imports) {
+      const outputPath = resolveOutputPath(file.imports[ref], ctx.config);
+      specifier.setLiteralValue(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();
+  };
+}
+function localResolver(dir) {
+  return async (file) => {
+    return await fs3.readFile(path4.join(dir, file)).then((res) => JSON.parse(res.toString())).catch(() => void 0);
+  };
+}
+
+// src/plugins/og-image.ts
+import picocolors3 from "picocolors";
+
+// src/generated.js
+var generated = { "lib/metadata": "import { createMetadataImage } from 'fumadocs-core/server';\nimport { source } from '@/lib/source';\n\nexport const metadataImage = createMetadataImage({\n  imageRoute: '/docs-og',\n  source,\n});\n", "app/docs-og/[...slug]/route": "import { generateOGImage } from 'fumadocs-ui/og';\nimport { metadataImage } from '@/lib/metadata';\n\nexport const GET = metadataImage.createAPI((page) => {\n  return generateOGImage({\n    title: page.data.title,\n    description: page.data.description,\n    site: 'My App',\n  });\n});\n\nexport function generateStaticParams() {\n  return metadataImage.generateParams();\n}\n", "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 { rimrafSync } from 'rimraf';\n\nconst out = './content/docs/(api)';\n\n// clean generated files\nrimrafSync(out, {\n  filter(v) {\n    return !v.endsWith('index.mdx') && !v.endsWith('meta.json');\n  },\n});\n\nvoid OpenAPI.generateFiles({\n  // input files\n  input: ['./openapi.json'],\n  output: out,\n  groupBy: 'tag',\n});\n" };
+
+// src/plugins/og-image.ts
+function isI18nEnabled(ctx) {
+  return exists(getOutputPath("lib/i18n.ts", ctx));
+}
+var ogImagePlugin = {
+  files: async (ctx) => {
+    const route = await isI18nEnabled(ctx) ? "app/[lang]/docs-og/[...slug]/route.tsx" : "app/docs-og/[...slug]/route.tsx";
+    return {
+      "lib/metadata.ts": generated["lib/metadata"],
+      [route]: generated["app/docs-og/[...slug]/route"]
+    };
+  },
+  dependencies: [],
+  instructions: (ctx) => [
+    {
+      type: "text",
+      text: picocolors3.cyanBright(picocolors3.bold("Import the utils like:"))
+    },
+    {
+      type: "code",
+      title: "ts",
+      code: 'import { metadataImage } from "@/lib/metadata";'
+    },
+    {
+      type: "text",
+      text: picocolors3.cyanBright(
+        picocolors3.bold("Add the images to your metadata:")
+      )
+    },
+    {
+      type: "code",
+      title: resolveAppPath("app/docs/[[...slug]]/page.tsx", ctx.src),
+      code: `
+export function generateMetadata({ params }: { params: { slug?: string[] } }) {
+  const page = source.getPage(params.slug);
+
+  if (!page) notFound();
+
+  ${picocolors3.bold(picocolors3.underline("return metadataImage.withImage(page.slugs, {"))}
+    title: page.data.title,
+    description: page.data.description,
+  });
+}
+`.trim()
+    }
+  ]
+};
+
+// src/plugins/i18n.ts
+import path7 from "node:path";
+import picocolors4 from "picocolors";
+import { log as log3 } from "@clack/prompts";
+
+// src/utils/i18n/transform-layout-config.ts
+import fs4 from "node:fs/promises";
+import { SyntaxKind } from "ts-morph";
+async function transformLayoutConfig(project, filePath) {
+  let content;
+  try {
+    content = await fs4.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 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) {
+  const stats = await fs5.lstat(from).catch(() => void 0);
+  if (!stats) return;
+  if (stats.isDirectory()) {
+    const items = await fs5.readdir(from);
+    await Promise.all(
+      items.map(async (item) => {
+        await moveFiles(
+          path5.resolve(from, item),
+          path5.resolve(to, item),
+          filter,
+          project,
+          src2,
+          originalDir
+        );
+      })
+    );
+    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)
+      },
+      (resolved) => {
+        if (resolved.type !== "file") return;
+        if (isRelative(originalDir, from) && filter(resolved.path)) return;
+        return toReferencePath(to, resolved.path);
+      }
+    );
+    await sourceFile.save();
+  }
+  await fs5.mkdir(path5.dirname(to), { recursive: true });
+  await fs5.rename(from, to);
+}
+
+// src/utils/i18n/transform-source-i18n.ts
+import * as fs6 from "node:fs/promises";
+import path6 from "node:path";
+import { StructureKind, SyntaxKind as SyntaxKind2 } from "ts-morph";
+async function transformSourceI18n(project, filePath, config) {
+  let content;
+  try {
+    content = await fs6.readFile(filePath).then((res) => res.toString());
+  } catch {
+    return;
+  }
+  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 fs7 from "node: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 fs7.readFile(filePath).then((res) => res.toString());
+  } catch {
+    return;
+  }
+  const sourceFile = project.createSourceFile(filePath, content, {
+    overwrite: true,
+    scriptKind: ScriptKind.TSX
+  });
+  runTransform(sourceFile);
+  return sourceFile.save();
+}
+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={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());
+  const param = func?.getParameters().at(0);
+  param?.setType(`{ params: { lang: string }, children: ReactNode }`);
+  param?.set({
+    name: `{ params, children }`
+  });
+}
+
+// src/plugins/i18n.ts
+var i18nPlugin = {
+  files: () => ({
+    "lib/i18n.ts": generated["lib/i18n"],
+    "middleware.ts": generated.middleware
+  }),
+  dependencies: [],
+  instructions: () => [
+    {
+      type: "text",
+      text: "Make sure to update the params of page.tsx and route.ts (if necessary):"
+    },
+    {
+      type: "code",
+      title: "page.tsx",
+      code: `
+export default function Page({
+  params,
+}: {
+  ${picocolors4.underline(picocolors4.bold("params: { lang: string; slug?: string[] };"))}
+})
+`.trim()
+    },
+    {
+      type: "text",
+      text: "Update the usages to `source` with:"
+    },
+    {
+      type: "code",
+      title: "page.tsx",
+      code: `const page = source.getPage(params.slug, params.lang);
+const pages = source.getPage(params.lang);`
+    },
+    {
+      type: "code",
+      title: "layout.tsx",
+      code: `const tree = source.pageTree[params.lang];`
+    }
+  ],
+  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) => {
+        return path7.basename(v, path7.extname(v)) !== "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 fs9 from "node:fs/promises";
+import path8 from "node:path";
+import { StructureKind as StructureKind3 } from "ts-morph";
+
+// src/utils/transform-tailwind.ts
+import fs8 from "node: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 transformTailwind(project, options) {
+  const file = await findTailwindConfig();
+  if (!file) {
+    log4.error(
+      "Cannot find Tailwind CSS configuration file, Tailwind CSS is required for this."
+    );
+    return;
+  }
+  const configFile = project.createSourceFile(
+    file,
+    await fs8.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 fs9.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 fs9.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 fs9.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();
+}
+
+// src/plugins/index.ts
+var plugins = {
+  "og-image": ogImagePlugin,
+  i18n: i18nPlugin,
+  openapi: openapiPlugin
+};
+
+// src/commands/file-tree.ts
+var scanned = ["file", "directory", "link"];
+function treeToMdx(input, noRoot = false) {
+  function toNode(item) {
+    if (item.type === "file" || item.type === "link") {
+      return `<File name=${JSON.stringify(item.name)} />`;
+    }
+    if (item.type === "directory") {
+      if (item.contents.length === 1 && "name" in item.contents[0]) {
+        const child = item.contents[0];
+        return toNode({
+          ...child,
+          name: `${item.name}/${child.name}`
+        });
+      }
+      return `<Folder name=${JSON.stringify(item.name)}>
+${item.contents.map(toNode).filter(Boolean).join("\n")}
+</Folder>`;
+    }
+    return "";
+  }
+  let children = input.filter((v) => scanned.includes(v.type));
+  if (noRoot && children.length === 1 && input[0].type === "directory") {
+    children = input[0].contents;
+  }
+  return `<Files>
+${children.map(toNode).filter(Boolean).join("\n")}
+</Files>`;
+}
+function treeToJavaScript(input, noRoot, importName = "fumadocs-ui/components/files") {
+  return `import { File, Files, Folder } from ${JSON.stringify(importName)}
+
+export default (${treeToMdx(input, noRoot)})`;
+}
+
+// src/utils/file-tree/run-tree.ts
+import { execa as execa3 } from "execa";
+async function runTree(args) {
+  const out = await execa3("tree", [args, "--gitignore", "--prune", "-J"]);
+  try {
+    return JSON.parse(out.stdout);
+  } catch (e) {
+    throw new Error("failed to run `tree` command", {
+      cause: e
+    });
+  }
+}
+
+// package.json
+var package_default = {
+  name: "@fumadocs/cli",
+  version: "0.0.1",
+  description: "The CLI tool for Fumadocs",
+  keywords: [
+    "NextJs",
+    "Docs",
+    "Fumadocs"
+  ],
+  homepage: "https://fumadocs.vercel.app",
+  repository: "github:fuma-nama/fumadocs",
+  license: "MIT",
+  author: "Fuma Nama",
+  type: "module",
+  exports: {
+    "./build": {
+      import: "./dist/build/index.js",
+      types: "./dist/build/index.d.ts"
+    }
+  },
+  main: "./dist/index.js",
+  bin: {
+    fumadocs: "./dist/index.js"
+  },
+  files: [
+    "dist/*"
+  ],
+  scripts: {
+    build: "tsup",
+    clean: "rimraf dist",
+    dev: "tsup --watch",
+    lint: "eslint .",
+    sync: "tsx ./scripts/sync.ts",
+    "types:check": "tsc --noEmit"
+  },
+  dependencies: {
+    "@clack/prompts": "^0.7.0",
+    commander: "^12.1.0",
+    execa: "^9.4.1",
+    "package-manager-detector": "^0.2.2",
+    picocolors: "^1.1.1",
+    "ts-morph": "^24.0.0"
+  },
+  devDependencies: {
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "22.7.8",
+    "@types/react": "^18.3.11",
+    "eslint-config-custom": "workspace:*",
+    "fast-glob": "^3.3.1",
+    tsconfig: "workspace:*",
+    tsx: "^4.19.1"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// 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 () => {
+  await initConfig();
+  console.log(picocolors5.green("Successful: ./cli.json"));
+});
+program.command("init").description("init a new plugin to your docs").argument("[string]", "plugin name").option("--config <string>").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 select({
+    message: "Select components to install",
+    options: Object.keys(plugins).map((c) => ({
+      label: c,
+      value: c
+    }))
+  });
+  if (isCancel3(value)) {
+    outro2("Ended");
+    return;
+  }
+  await init(plugins[value], loadedConfig);
+});
+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(
+  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);
+    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")));
+      if (!registry) {
+        log5.error(`Failed to fetch '_registry.json' file from ${dir}`);
+        throw new Error(`Failed to fetch registry`);
+      }
+      const value = await multiselect({
+        message: "Select components to install",
+        options: registry.map((item) => ({
+          label: item.name,
+          value: item.name,
+          hint: item.description
+        }))
+      });
+      if (isCancel3(value)) {
+        outro2("Ended");
+        return;
+      }
+      target = value;
+    }
+    const loadedConfig = await loadConfig(options.config);
+    for (const name of target) {
+      await add(name, resolver, loadedConfig);
+    }
+  }
+);
+program.command("tree").argument(
+  "[json_or_args]",
+  "JSON output of `tree` command or arguments for the `tree` command"
+).argument("[output]", "output path of file").option("--js", "output as JavaScript file").option("--no-root", "remove the root node").option("--import-name <name>", "where to import components (JS only)").action(
+  async (str, output, {
+    js,
+    root,
+    importName
+  }) => {
+    const jsExtensions = [".js", ".tsx", ".jsx"];
+    const noRoot = !root;
+    let nodes;
+    try {
+      nodes = JSON.parse(str ?? "");
+    } catch {
+      nodes = await runTree(str ?? "./");
+    }
+    const out = js || output && jsExtensions.includes(path9.extname(output)) ? treeToJavaScript(nodes, noRoot, importName) : treeToMdx(nodes, noRoot);
+    if (output) {
+      await fs10.mkdir(path9.dirname(output), { recursive: true });
+      await fs10.writeFile(output, out);
+    } else {
+      console.log(out);
+    }
+  }
+);
+program.parse();