@xyd-js/cli 0.0.0-build

package/dist/index.js

@@ -0,0 +1,1549 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli.ts
+import semver from "semver";
+import updateNotifier from "update-notifier";
+
+// src/const.ts
+var MIN_NODE_VERSION = 22;
+
+// src/utils.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import colors from "picocolors";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var packageJsonPath = join(__dirname, "..", "package.json");
+var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+function getPackageJson() {
+  return packageJson;
+}
+function getVersion() {
+  return packageJson.version;
+}
+function printHelp() {
+  console.log(`
+${colors.blueBright(cliSpec.name)} \u2014 ${cliSpec.description}
+`);
+  console.log(`${colors.underline("Usage")}:
+  ${cliSpec.usage}
+`);
+  console.log(`${colors.underline("Global Flags")}:`);
+  for (const [flag, meta] of Object.entries(cliSpec.globalFlags)) {
+    let flagDisplay;
+    if (meta.alias) {
+      flagDisplay = `  -${meta.alias}, --${flag}`;
+    } else {
+      flagDisplay = `      --${flag}`;
+    }
+    console.log(`${flagDisplay.padEnd(20)} ${meta.description}`);
+  }
+  console.log(`
+${colors.underline("Commands")}:`);
+  for (const [cmd, meta] of Object.entries(cliSpec.commands)) {
+    console.log(`  ${cmd.padEnd(10)} ${meta.description}`);
+  }
+  console.log(`
+Use \`--help\` with a command for more info.
+`);
+}
+
+// src/spec.ts
+var cliSpec = {
+  name: "xyd",
+  version: getVersion(),
+  description: "Docs platform for future dev",
+  usage: "xyd [globalFlags] [command]",
+  commands: {
+    dev: {
+      description: "Run your docs locally in development mode",
+      usage: "xyd dev [flags]"
+    },
+    build: {
+      description: "Build your docs",
+      usage: "xyd build [flags]"
+    },
+    install: {
+      description: "Install the xyd framework manually",
+      usage: "xyd install [flags]"
+    },
+    migrateme: {
+      description: "Migrate your docs to the new xyd framework",
+      usage: "xyd migrateme  <resource> [flags]"
+    },
+    components: {
+      description: "Manage xyd components",
+      usage: "xyd components <subcommand> [args] [flags]"
+    }
+  },
+  globalFlags: {
+    "help": {
+      alias: "h",
+      type: "Boolean",
+      description: "Print this help message and exit"
+    },
+    "version": {
+      alias: "v",
+      type: "Boolean",
+      description: "Print the CLI version and exit"
+    },
+    "verbose": {
+      type: "Boolean",
+      description: "Enable verbose output"
+    },
+    "port": {
+      alias: "p",
+      type: "Number",
+      description: "Port to run the dev server on"
+    },
+    "logLevel": {
+      alias: "l",
+      type: "String",
+      description: "Set logging level (e.g. info, debug)"
+    },
+    "debug": {
+      type: "Boolean",
+      description: "Enable debug output"
+    }
+  }
+};
+
+// src/args.ts
+import arg from "arg";
+function parseArgs(argv) {
+  const argSpec = Object.fromEntries(
+    Object.entries(cliSpec.globalFlags).flatMap(([flag, meta]) => {
+      const type = getArgType(meta.type);
+      const flagWithPrefix = `--${flag}`;
+      const entries = [[flagWithPrefix, type]];
+      if (meta.alias) entries.push([`-${meta.alias}`, flagWithPrefix]);
+      return entries;
+    })
+  );
+  const parsed = arg(argSpec, { argv });
+  const commands = parsed._;
+  const globalFlags = Object.fromEntries(
+    Object.entries(parsed).filter(([key]) => key !== "_").map(([key, value]) => [key.replace(/^--/, ""), value])
+  );
+  return { globalFlags, commands };
+}
+function getArgType(flagType) {
+  switch (flagType) {
+    case "Boolean":
+      return Boolean;
+    case "Number":
+      return Number;
+    case "String":
+      return String;
+    default:
+      return String;
+  }
+}
+
+// src/commands/index.ts
+var commands_exports = {};
+__export(commands_exports, {
+  build: () => build,
+  components: () => components,
+  dev: () => dev2,
+  install: () => install2,
+  migrateme: () => migrateme
+});
+
+// src/commands/build.ts
+import { spawn } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+async function build() {
+  const __filename2 = fileURLToPath2(import.meta.url);
+  const __dirname2 = dirname2(__filename2);
+  const buildScript = join2(__dirname2, "..", "dist", "build.js");
+  return new Promise((resolve2, reject) => {
+    const args = process.argv.slice(2);
+    const child = spawn("node", [buildScript, ...args], {
+      stdio: "inherit",
+      // This will show output in stdout
+      shell: true,
+      env: {
+        NODE_ENV: "production",
+        ...process.env
+        // Pass through all existing environment variables
+      }
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2(void 0);
+      } else {
+        reject(new Error(`Build process exited with code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+// src/commands/dev.ts
+import * as documan from "@xyd-js/documan";
+async function dev2(options = {}) {
+  await documan.dev(options);
+  await new Promise(() => {
+  });
+}
+
+// src/commands/install.ts
+import * as documan2 from "@xyd-js/documan";
+async function install2() {
+  await documan2.install();
+}
+
+// src/commands/migrateme/migrateme.ts
+import { existsSync as existsSync3 } from "fs";
+
+// src/commands/migrateme/utils.ts
+import { cwd } from "process";
+import { writeFile, mkdir, rm, readdir } from "fs/promises";
+import { isAbsolute, join as join3, resolve } from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { homedir } from "os";
+function isGitHubRepo(url) {
+  const githubRawPattern = /^https:\/\/raw\.githubusercontent\.com\/([^\/]+)\/([^\/]+)\/([^\/]+)\/(.+)$/;
+  const githubRepoPattern = /^https:\/\/github\.com\/([^\/]+)\/([^\/]+)(?:\/.*)?$/;
+  return githubRawPattern.test(url) || githubRepoPattern.test(url);
+}
+function parseGitHubUrl(url) {
+  const rawUrlMatch = url.match(/^https:\/\/raw\.githubusercontent\.com\/([^\/]+)\/([^\/]+)\/([^\/]+)\/(.+)$/);
+  if (rawUrlMatch) {
+    const [, owner2, repo2, branch2, filePath] = rawUrlMatch;
+    return { owner: owner2, repo: repo2, branch: branch2, directory: filePath.split("/").slice(0, -1).join("/") };
+  }
+  const repoUrlMatch = url.match(/^https:\/\/github\.com\/([^\/]+)\/([^\/]+)(?:\/.*)?$/);
+  if (!repoUrlMatch) {
+    throw new Error("Invalid GitHub URL format");
+  }
+  const [, owner, repo] = repoUrlMatch;
+  const urlPath = url.replace(`https://github.com/${owner}/${repo}`, "");
+  const pathParts = urlPath.split("/").filter((part) => part.length > 0);
+  let branch = "main";
+  let directory;
+  if (pathParts.length >= 2 && pathParts[0] === "tree") {
+    branch = pathParts[1];
+    if (pathParts.length > 2) {
+      directory = pathParts.slice(2).join("/");
+    }
+  } else if (pathParts.length >= 1) {
+    branch = pathParts[0];
+    if (pathParts.length > 1) {
+      directory = pathParts.slice(1).join("/");
+    }
+  }
+  return { owner, repo, branch, directory };
+}
+async function downloadGitHubRepo(docsUrl, flags) {
+  try {
+    console.log("GitHub repo detected, downloading entire repository...");
+    const { owner, repo, branch, directory } = parseGitHubUrl(docsUrl);
+    const repoUrl = `https://github.com/${owner}/${repo}`;
+    const downloadUrl = `https://github.com/${owner}/${repo}/archive/refs/heads/${branch}.zip`;
+    console.log(`Repository: ${repoUrl}`);
+    console.log(`Branch: ${branch}`);
+    if (directory) {
+      console.log(`Directory: ${directory}`);
+    }
+    console.log(`Download URL: ${downloadUrl}`);
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to download repository: ${response.statusText}`);
+    }
+    const filename = `${repo}-${branch}.zip`;
+    console.log(`Downloading ${filename}...`);
+    const saveDir = flags.dir || cwd();
+    const savePath = join3(saveDir, filename);
+    try {
+      await mkdir(saveDir, { recursive: true });
+    } catch (error) {
+    }
+    const buffer = await response.arrayBuffer();
+    await writeFile(savePath, Buffer.from(buffer));
+    console.log(`Successfully downloaded repository: ${filename}`);
+    console.log(`Saved to: ${savePath}`);
+    console.log("Extracting ZIP file...");
+    const extractDir = join3(saveDir, `${repo}-${branch}`);
+    try {
+      await rm(extractDir, { recursive: true, force: true });
+    } catch (error) {
+    }
+    const execAsync2 = promisify(exec);
+    try {
+      console.log("Starting extraction...");
+      const tempExtractDir = join3(saveDir, "temp-extract");
+      console.log(`Extracting to temp dir: ${tempExtractDir}`);
+      await execAsync2(`unzip -o -q "${savePath}" -d "${tempExtractDir}"`);
+      console.log("ZIP extraction completed");
+      const tempFiles = await readdir(tempExtractDir, { withFileTypes: true });
+      const repoDir = tempFiles.find((file) => file.isDirectory());
+      if (repoDir) {
+        const sourceDir = join3(tempExtractDir, repoDir.name);
+        if (directory) {
+          const targetDir = join3(sourceDir, directory);
+          console.log(`Moving files from ${targetDir} to ${saveDir}`);
+          try {
+            await execAsync2(`test -d "${targetDir}"`);
+          } catch (error) {
+            throw new Error(`Directory '${directory}' not found in repository`);
+          }
+          await execAsync2(`cp -r "${targetDir}"/* "${saveDir}/"`);
+          console.log(`Files from '${directory}' directory copied successfully`);
+        } else {
+          console.log(`Moving files from ${sourceDir} to ${saveDir}`);
+          await execAsync2(`cp -r "${sourceDir}"/* "${saveDir}/"`);
+          console.log("Files copied successfully");
+        }
+        await rm(tempExtractDir, { recursive: true, force: true });
+        console.log("Temp directory cleaned up");
+      } else {
+        throw new Error("Could not find repository directory in ZIP");
+      }
+    } catch (error) {
+      console.error("Error during extraction:", error);
+      try {
+        console.log("Trying tar fallback...");
+        await execAsync2(`tar -xf "${savePath}" --strip-components=1 -C "${saveDir}"`);
+        console.log("Tar extraction completed");
+      } catch (tarError) {
+        console.warn("Could not extract ZIP file automatically. Please extract manually.");
+        console.log(`ZIP file saved at: ${savePath}`);
+        return saveDir;
+      }
+    }
+    await rm(savePath);
+    console.log(`Successfully extracted to: ${saveDir}`);
+    return saveDir;
+  } catch (error) {
+    console.error("Error downloading repository:", error);
+    throw error;
+  }
+}
+function resolveResourcePath(resource) {
+  if (resource === "." || resource === "./") {
+    return cwd();
+  }
+  if (resource.startsWith("~/")) {
+    return resolve(homedir(), resource.slice(2));
+  }
+  if (isAbsolute(resource)) {
+    return resource;
+  }
+  return resolve(cwd(), resource);
+}
+async function cleanDirectory(dirPath) {
+  try {
+    console.log("Cleaning folder before processing...");
+    const files = await readdir(dirPath, { withFileTypes: true });
+    for (const file of files) {
+      const filePath = join3(dirPath, file.name);
+      if (file.isDirectory()) {
+        await rm(filePath, { recursive: true, force: true });
+      } else {
+        await rm(filePath, { force: true });
+      }
+    }
+    console.log("Directory cleaned successfully");
+  } catch (error) {
+    console.warn("Warning: Could not clean directory:", error);
+  }
+}
+
+// src/commands/migrateme/cli.ts
+import { cwd as cwd2 } from "process";
+import readline from "readline";
+async function askForConfirmation(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    const coloredQuestion = `\x1B[36m${question}\x1B[0m (y/n): `;
+    rl.question(coloredQuestion, (answer) => {
+      rl.close();
+      const normalizedAnswer = answer.toLowerCase().trim();
+      resolve2(normalizedAnswer === "y" || normalizedAnswer === "yes");
+    });
+  });
+}
+async function askForClean(migratemeFlags) {
+  const saveDir = migratemeFlags.dir || cwd2();
+  const shouldClean = await askForConfirmation("Should the folder be cleaned before processing?");
+  if (shouldClean) {
+    await cleanDirectory(saveDir);
+  }
+}
+async function askForStart() {
+  const shouldStart = await askForConfirmation("Do you want to start the migration?");
+  if (!shouldStart) {
+    console.log("Migration cancelled");
+    process.exit(0);
+  }
+}
+
+// src/commands/migrateme/migration.ts
+import { readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { promisify as promisify3 } from "util";
+import { exec as exec3 } from "child_process";
+
+// src/commands/migrateme/mintlify/mintlify.ts
+import { join as join4, relative, sep } from "path";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { existsSync } from "fs";
+import { readdir as readdir2, readFile, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { createProcessor } from "@mdx-js/mdx";
+import { remark } from "remark";
+import remarkDirective from "remark-directive";
+import remarkStringify from "remark-stringify";
+async function isMintlify(docsPath, fileName) {
+  if (!MintlifyMigrator.validMintlifyJsonFile(fileName)) return false;
+  console.log("Found docs.json file, checking if it's Mintlify...");
+  const docsJsonPath = join4(docsPath, fileName);
+  const content = await readFile(docsJsonPath, "utf-8");
+  let data = null;
+  try {
+    data = JSON.parse(content);
+  } catch (_) {
+  }
+  if (MintlifyMigrator.isMintlifyJson(data)) {
+    console.log("\u2705 Mintlify framework detected!");
+    return true;
+  } else {
+    console.log("\u274C docs.json found but not a valid Mintlify configuration");
+    return false;
+  }
+}
+async function mintlifyMigrator(docsPath, options) {
+  return new MintlifyMigrator(docsPath, options).run();
+}
+var sh = promisify2(exec2);
+var Logger = class {
+  constructor(enabled = true, verbose = false) {
+    this.enabled = enabled;
+    this.stepCount = 0;
+    this.totalSteps = 0;
+    this.errors = [];
+    this.docsPath = "";
+    this.info = (...args) => this.enabled && console.log("   \u2139\uFE0F ", ...args);
+    this.warn = (...args) => this.enabled && console.warn("   \u26A0\uFE0F ", ...args);
+    this.error = (...args) => {
+      console.error("   \u274C", ...args);
+      this.errors.push({ error: args.join(" ") });
+    };
+    this.errorVerbose = (error, context) => {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const fullError = error instanceof Error ? error.stack || String(error) : String(error);
+      console.error("   \u274C", context ? `${context}: ${errorMessage}` : errorMessage);
+      if (this.verbose && fullError !== errorMessage) {
+        console.error("   \u{1F50D} Full error details:");
+        console.error("   " + fullError.split("\n").join("\n   "));
+      }
+      let file;
+      if (context) {
+        const fileMatch = context.match(/Failed to migrate (.+)$/);
+        if (fileMatch) {
+          file = fileMatch[1];
+        }
+      }
+      this.errors.push({ file, error: context ? `${context}: ${errorMessage}` : errorMessage });
+    };
+    this.debug = (...args) => this.enabled && console.log("   \u{1F50D}", ...args);
+    this.success = (...args) => this.enabled && console.log("   \u2705", ...args);
+    this.progress = (...args) => this.enabled && console.log("   \u{1F4DD}", ...args);
+    this.file = (...args) => this.enabled && console.log("   \u{1F4C4}", ...args);
+    this.resource = (...args) => this.enabled && console.log("   \u{1F5BC}\uFE0F ", ...args);
+    this.details = (summary, content) => {
+      if (!this.verbose) return;
+      console.log(`   \u{1F4CB} ${summary}:`);
+      const lines = Array.isArray(content) ? content : content.split("\n");
+      lines.forEach((line) => {
+        console.log("   " + line);
+      });
+      console.log("   ");
+    };
+    this.verbose = verbose;
+  }
+  setDocsPath(docsPath) {
+    this.docsPath = docsPath;
+  }
+  startMigration(totalSteps) {
+    this.totalSteps = totalSteps;
+    this.stepCount = 0;
+    this.errors = [];
+    console.log("\n\u{1F680} Starting Mintlify to xyd migration...");
+    console.log("=".repeat(50));
+  }
+  step(message) {
+    this.stepCount++;
+    const progress = `[${this.stepCount}/${this.totalSteps}]`;
+    console.log(`
+${progress} ${message}`);
+  }
+  addError(file, error) {
+    this.errors.push({ file, error });
+  }
+  complete() {
+    console.log("\n" + "=".repeat(50));
+    if (this.errors.length > 0) {
+      console.log("\u26A0\uFE0F  Migration completed with errors:");
+      console.log("=".repeat(50));
+      console.log(`   ${this.errors.length} error(s) encountered:`);
+      this.errors.forEach((err, index) => {
+        if (err.file) {
+          console.log(`   ${index + 1}. File: ${err.file}`);
+          console.log(`      Error: ${err.error}`);
+        } else {
+          console.log(`   ${index + 1}. ${err.error}`);
+        }
+      });
+      console.log("\n   Some files may not have been migrated correctly.");
+      console.log("   Please review the errors above and fix any issues.");
+      if (!this.verbose) {
+        console.log("   Run with --verbose flag to see detailed error information.");
+      }
+    } else {
+      console.log("\u{1F389} Migration completed successfully!");
+    }
+    console.log("\n\u{1F4D6} Next steps:");
+    console.log(`   \u2022 cd "${this.docsPath}"`);
+    console.log("   \u2022 Run `xyd` to start the development server");
+    console.log("   \u2022 Run `xyd build` to build static HTML files");
+    console.log("   \u2022 Visit http://localhost:3000 to preview your docs");
+    console.log("\n\u{1F4A1} Learn more:");
+    console.log("   \u2022 Visit https://xyd.dev for documentation and examples");
+    console.log("   \u2022 \u2B50 Star us on GitHub: https://github.com/livesession/xyd");
+    console.log("   \u2022 \u{1F680} Help us grow by giving us a star! \u2728");
+    console.log("=".repeat(50) + "\n");
+  }
+};
+var MintlifyMigrator = class {
+  constructor(docsPath, options = {}) {
+    this.docsPath = docsPath;
+    this.options = options;
+    this.docsJsonPath = "";
+    this.publicDir = "";
+    this.logger = new Logger(true, options.verbose || false);
+    this.logger.setDocsPath(docsPath);
+  }
+  static isMintlifyJson(data) {
+    return !!(data && typeof data === "object" && data.$schema === "https://mintlify.com/docs.json");
+  }
+  async run() {
+    this.logger.startMigration(5);
+    this.logger.step("\u{1F50D}Analyzing Mintlify configuration");
+    this.docsJsonPath = join4(this.docsPath, "docs.json");
+    try {
+      if (!existsSync(this.docsJsonPath)) {
+        this.docsJsonPath = join4(this.docsPath, "mint.json");
+      }
+    } catch (_) {
+      this.docsJsonPath = join4(this.docsPath, "mint.json");
+    }
+    this.docsJson = JSON.parse(await readFile(this.docsJsonPath, "utf-8"));
+    if (!this.docsJson) {
+      this.logger.error("Invalid Mintlify configuration: missing or incorrect.");
+      return;
+    }
+    this.logger.success("Configuration file found and parsed");
+    this.logger.step("\u2699\uFE0FPreparing xyd settings and directories");
+    this.xydSettings = this.preSettings(this.docsJson);
+    await this.ensurePublicDir();
+    this.logger.success("Settings prepared and public directory ready");
+    this.logger.step("\u{1F504}Converting Mintlify configuration to xyd format");
+    await this.mintlifyDocsJsonToXydSettings();
+    this.logger.success("Configuration converted successfully");
+    this.logger.step("\u{1F4BE}Writing xyd configuration file");
+    await writeFile2(join4(this.docsPath, "docs.json"), JSON.stringify(this.xydSettings, null, 2));
+    this.logger.success("Configuration file written");
+    this.logger.step("\u{1F4DD}Migrating content files (MDX \u2192 Markdown)");
+    await this.migrateContent();
+    this.logger.success("Content migration completed");
+    this.logger.complete();
+  }
+  // ---------------------------------------------------------------------------
+  // Stage 0: bootstrap
+  // ---------------------------------------------------------------------------
+  preSettings(docsJson) {
+    let theme = "gusto";
+    if (docsJson.theme && docsJson.theme === "maple") {
+      theme = "gusto";
+    } else if (docsJson.theme && docsJson.theme === "mint") {
+      theme = "solar";
+    }
+    return {
+      theme: {
+        name: theme,
+        icons: {
+          library: [
+            {
+              name: "fa6-solid",
+              // TODO: mintlify supports lucide icons too
+              default: true
+            }
+          ]
+        },
+        writer: {
+          maxTocDepth: 4
+        }
+      },
+      webeditor: {
+        header: []
+      },
+      navigation: {
+        tabs: [],
+        sidebar: []
+      },
+      components: {}
+    };
+  }
+  async ensurePublicDir() {
+    this.publicDir = join4(this.docsPath, "public");
+    try {
+      await readdir2(this.publicDir);
+      this.logger.info("Public directory already exists");
+    } catch {
+      this.logger.progress("Creating public directory...");
+      await sh(`mkdir -p "${this.publicDir}"`);
+      this.logger.success("Public directory created");
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Stage 1: docs.json → settings
+  // ---------------------------------------------------------------------------
+  async mintlifyDocsJsonToXydSettings() {
+    this.migrateNavigation();
+    this.migrateColors();
+    await this.migrateLogo();
+    await this.migrateFavicon();
+    await this.migratePublicResources();
+    this.migrateNavbarLinks();
+    this.migrateFooter();
+    this.migrateRedirects();
+    this.migrateSeo();
+  }
+  // ---------------------------------------------------------------------------
+  // Navigation
+  // ---------------------------------------------------------------------------
+  migrateNavigation() {
+    const docsJson = this.docsJson;
+    const xydSettings = this.xydSettings;
+    const migrateNav = (navs) => {
+      for (const nav of navs) {
+        const hasHref = "href" in nav && nav.href;
+        const hasGroups = "groups" in nav && nav.groups || "pages" in nav && nav.pages && this.hasNestedGroups(nav.pages);
+        const hasPages = "pages" in nav && nav.pages;
+        let title = "";
+        if ("group" in nav) title = nav.group;
+        else if ("tab" in nav) title = nav.tab;
+        else if ("dropdown" in nav) title = nav.dropdown;
+        else if ("anchor" in nav) title = nav.anchor;
+        const headerEntry = {
+          title,
+          icon: "icon" in nav ? typeof nav.icon === "string" ? nav.icon : nav.icon?.name : ""
+        };
+        if (hasHref && !hasGroups && !hasPages) {
+          headerEntry.href = nav.href;
+          headerEntry.float = "right";
+        } else if (hasGroups) {
+          let route = title.toLowerCase().replace(/\s+/g, "-");
+          if ("pages" in nav && nav.pages && !("groups" in nav && nav.groups)) {
+            if (this.isFlatStructure(nav.pages)) {
+              headerEntry.page = "";
+              const flatSidebarPages = [];
+              for (const pageOrGroup of nav.pages) {
+                if (typeof pageOrGroup === "string") {
+                  if (pageOrGroup === "index") {
+                    this.logger.warn("currently skipping index page in sidebar");
+                    continue;
+                  }
+                  flatSidebarPages.push(pageOrGroup);
+                } else if (typeof pageOrGroup === "object" && pageOrGroup.group && pageOrGroup.pages) {
+                  for (const nestedPage of pageOrGroup.pages) {
+                    if (nestedPage === "index") {
+                      this.logger.warn("currently skipping index page in sidebar");
+                      continue;
+                    }
+                    flatSidebarPages.push(nestedPage);
+                  }
+                }
+              }
+              xydSettings.navigation.sidebar.push(...flatSidebarPages);
+              xydSettings.navigation.tabs.push(headerEntry);
+              continue;
+            } else {
+              const firstPage = nav.pages[0];
+              if (typeof firstPage === "string") route = firstPage;
+              else if (typeof firstPage === "object" && firstPage.pages && firstPage.pages[0])
+                route = firstPage.pages[0];
+            }
+          }
+          headerEntry.page = route;
+          const sidebarPages = [];
+          if ("groups" in nav && nav.groups) {
+            for (const group of nav.groups ?? []) {
+              if ("pages" in group && group.pages) {
+                const pages = [];
+                for (const pageOrGroup of group.pages) {
+                  if (pageOrGroup === "index") {
+                    this.logger.warn("currently skipping index page in sidebar");
+                    continue;
+                  }
+                  pages.push(pageOrGroup);
+                }
+                sidebarPages.push({ group: group.group, pages });
+              }
+            }
+          } else if ("pages" in nav && nav.pages) {
+            for (const pageOrGroup of nav.pages) {
+              if (typeof pageOrGroup === "string") {
+                if (pageOrGroup === "index") {
+                  this.logger.warn("currently skipping index page in sidebar");
+                  continue;
+                }
+                sidebarPages.push(pageOrGroup);
+              } else if (typeof pageOrGroup === "object" && pageOrGroup.group && pageOrGroup.pages) {
+                sidebarPages.push({ group: pageOrGroup.group, pages: pageOrGroup.pages });
+              }
+            }
+          }
+          const isValidRoute = this.validateRoutePages(route, sidebarPages);
+          if (isValidRoute) {
+            xydSettings.navigation.sidebar.push({ route, pages: sidebarPages });
+          } else {
+            xydSettings.navigation.sidebar.push(...sidebarPages);
+            headerEntry.page = "";
+            const firstPage = this.findFirstPage(sidebarPages);
+            if (firstPage) {
+              headerEntry.href = "/" + firstPage;
+            }
+          }
+        } else if (hasPages && !hasGroups) {
+          headerEntry.page = "";
+          if ("pages" in nav && nav.pages && nav.pages.length > 0) {
+            const firstPage = nav.pages[0];
+            if (typeof firstPage === "string") {
+              headerEntry.href = firstPage;
+            }
+          } else {
+          }
+          xydSettings.navigation.sidebar.push(title.toLowerCase().replace(/\s+/g, "-"));
+        }
+        xydSettings.navigation.tabs.push(headerEntry);
+      }
+    };
+    if ("groups" in docsJson.navigation) {
+      this.logger.progress("Migrating navigation groups...");
+      migrateNav(docsJson.navigation.groups);
+      this.logger.success("Navigation groups migrated");
+    }
+    if ("tabs" in docsJson.navigation) {
+      this.logger.progress("Migrating navigation tabs...");
+      migrateNav(docsJson.navigation.tabs);
+      this.logger.success("Navigation tabs migrated");
+    }
+    if ("anchors" in docsJson.navigation) {
+      this.logger.progress("Migrating navigation anchors...");
+      migrateNav(docsJson.navigation.anchors);
+      this.logger.success("Navigation anchors migrated");
+    }
+    if ("dropdowns" in docsJson.navigation) {
+      this.logger.progress("Migrating navigation dropdowns...");
+      migrateNav(docsJson.navigation.dropdowns);
+      this.logger.success("Navigation dropdowns migrated");
+    }
+    if ("versions" in docsJson.navigation) {
+      this.logger.warn("Version navigation is not currently supported");
+      this.logger.info("Only the first version navigation will be created");
+      this.logger.info("\u{1F4CB} Roadmap: https://github.com/orgs/livesession/projects/4");
+      if (docsJson.navigation?.versions?.length) {
+        const firstVersion = docsJson.navigation.versions[0];
+        if ("groups" in firstVersion && firstVersion.groups) {
+          this.logger.progress("Migrating first version navigation...");
+          migrateNav([firstVersion]);
+          this.logger.success("First version navigation migrated");
+        }
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Theme & branding
+  // ---------------------------------------------------------------------------
+  migrateColors() {
+    var _a;
+    const { docsJson, xydSettings } = this;
+    if (!docsJson.colors) return;
+    this.logger.progress("Migrating theme colors...");
+    (_a = xydSettings.theme).appearance || (_a.appearance = {});
+    xydSettings.theme.appearance.colors = {
+      primary: docsJson.colors.primary,
+      dark: docsJson.colors.dark,
+      light: docsJson.colors.light
+    };
+    this.logger.success("Theme colors migrated");
+  }
+  async migrateLogo() {
+    const { docsJson } = this;
+    if (!docsJson.logo) return;
+    this.logger.progress("Migrating logo...");
+    if (typeof docsJson.logo === "string") {
+      this.xydSettings.theme.logo = await this.moveResourceToPublic(docsJson.logo);
+    } else if (typeof docsJson.logo === "object") {
+      this.xydSettings.theme.logo = {
+        light: await this.moveResourceToPublic(docsJson.logo.light),
+        dark: await this.moveResourceToPublic(docsJson.logo.dark),
+        href: docsJson.logo.href
+      };
+    }
+    this.logger.success("Logo migrated");
+  }
+  async migrateFavicon() {
+    const { docsJson } = this;
+    if (!docsJson.favicon) return;
+    this.logger.progress("Migrating favicon...");
+    if (typeof docsJson.favicon === "string") {
+      this.xydSettings.theme.favicon = await this.moveResourceToPublic(docsJson.favicon);
+    } else if (typeof docsJson.favicon === "object") {
+      const lightFavicon = await this.moveResourceToPublic(docsJson.favicon.light);
+      const darkFavicon = await this.moveResourceToPublic(docsJson.favicon.dark);
+      this.xydSettings.theme.favicon = lightFavicon || darkFavicon;
+    }
+    this.logger.success("Favicon migrated");
+  }
+  migrateNavbarLinks() {
+    const { docsJson, xydSettings } = this;
+    if (!docsJson.navbar?.links) return;
+    this.logger.progress("Migrating navbar links...");
+    xydSettings.webeditor.header = docsJson.navbar.links.map((link) => ({
+      title: link.label,
+      href: link.href,
+      icon: typeof link.icon === "string" ? link.icon : link.icon?.name,
+      float: "right"
+    }));
+    this.logger.success("Navbar links migrated");
+  }
+  migrateFooter() {
+    const { docsJson, xydSettings } = this;
+    if (!docsJson.footer) return;
+    this.logger.progress("Migrating footer...");
+    const xydSocials = {};
+    if (docsJson.footer.socials) {
+      const supported = [
+        "x",
+        "facebook",
+        "youtube",
+        "discord",
+        "slack",
+        "github",
+        "linkedin",
+        "instagram",
+        "hackernews",
+        "medium",
+        "telegram",
+        "bluesky",
+        "reddit"
+      ];
+      for (const [platform, url] of Object.entries(docsJson.footer.socials)) {
+        if (supported.includes(platform)) xydSocials[platform] = url;
+      }
+    }
+    xydSettings.components.footer = {
+      social: Object.keys(xydSocials).length > 0 ? xydSocials : void 0,
+      links: docsJson.footer.links?.map((group) => ({
+        header: group.header || "",
+        items: group.items.map((item) => ({ label: item.label, href: item.href }))
+      }))
+    };
+    this.logger.success("Footer migrated");
+  }
+  migrateRedirects() {
+    if (this.docsJson.redirects) {
+      this.logger.warn("Redirects are not currently supported in xyd");
+      this.logger.info("Redirects will be skipped");
+    }
+  }
+  migrateSeo() {
+    if (!this.docsJson.seo) return;
+    this.logger.progress("Migrating SEO settings...");
+    this.xydSettings.seo = { metatags: this.docsJson.seo.metatags || void 0 };
+    this.logger.success("SEO settings migrated");
+  }
+  // ---------------------------------------------------------------------------
+  // Assets
+  // ---------------------------------------------------------------------------
+  async moveResourceToPublic(resourcePath) {
+    if (!resourcePath) return "";
+    const cleanPath = resourcePath.startsWith("/") ? resourcePath.slice(1) : resourcePath;
+    if (cleanPath.startsWith("public/")) return `/${cleanPath}`;
+    const sourcePath = join4(this.docsPath, cleanPath);
+    try {
+      await readFile(sourcePath);
+      const relativePath = cleanPath;
+      const destPath = join4(this.publicDir, relativePath);
+      const destDir = destPath.substring(0, destPath.lastIndexOf("/"));
+      try {
+        await readdir2(destDir);
+      } catch {
+        await sh(`mkdir -p "${destDir}"`);
+      }
+      await sh(`mv "${sourcePath}" "${destPath}"`);
+      this.logger.resource(`Moved: ${cleanPath}`);
+      return `/public/${relativePath}`;
+    } catch (_) {
+      this.logger.info(`Resource not found or already in public: ${cleanPath}`);
+      return resourcePath;
+    }
+  }
+  async migratePublicResources() {
+    this.logger.progress("Scanning for image resources...");
+    const imageExtensions = /* @__PURE__ */ new Set([".svg", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico"]);
+    let movedCount = 0;
+    let skippedCount = 0;
+    const scan = async (currentDir) => {
+      const items = await readdir2(currentDir, { withFileTypes: true });
+      for (const item of items) {
+        const fullPath = join4(currentDir, item.name);
+        if (item.isDirectory()) {
+          if (!(/* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "public"])).has(item.name)) {
+            await scan(fullPath);
+          }
+        } else if (item.isFile()) {
+          const dot = item.name.lastIndexOf(".");
+          const ext = dot >= 0 ? item.name.toLowerCase().substring(dot) : "";
+          if (!imageExtensions.has(ext)) continue;
+          try {
+            const rel = relative(this.docsPath, fullPath).split(sep).join("/");
+            const destPath = join4(this.publicDir, rel);
+            const destDir = destPath.substring(0, destPath.lastIndexOf("/"));
+            try {
+              await readdir2(destDir);
+            } catch {
+              await sh(`mkdir -p "${destDir}"`);
+            }
+            try {
+              await readFile(destPath);
+              this.logger.info(`Image already exists in public: ${rel}`);
+              skippedCount++;
+            } catch {
+              await sh(`mv "${fullPath}" "${destPath}"`);
+              this.logger.resource(`Moved: ${rel}`);
+              movedCount++;
+            }
+          } catch (error) {
+            this.logger.errorVerbose(error, `Error moving image ${item.name}`);
+          }
+        }
+      }
+    };
+    await scan(this.docsPath);
+    if (movedCount > 0 || skippedCount > 0) {
+      this.logger.success(`Public resources migrated: ${movedCount} moved, ${skippedCount} already existed`);
+    } else {
+      this.logger.info("No image resources found to migrate");
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Content (.mdx → .md)
+  // ---------------------------------------------------------------------------
+  async migrateContent() {
+    this.logger.progress("Scanning for MDX files...");
+    const mdxFiles = await this.findMdxFiles(this.docsPath);
+    this.logger.info(`Found ${mdxFiles.length} MDX files to migrate`);
+    let successCount = 0;
+    let errorCount = 0;
+    for (const mdxFile of mdxFiles) {
+      try {
+        await this.migrateMdxFile(mdxFile);
+        successCount++;
+      } catch (error) {
+        errorCount++;
+        const relativePath = relative(this.docsPath, mdxFile);
+        this.logger.errorVerbose(error, `Failed to migrate ${relativePath}`);
+      }
+    }
+    if (errorCount > 0) {
+      this.logger.warn(`Content migration completed with ${errorCount} error(s)`);
+      this.logger.success(`${successCount} files migrated successfully`);
+    } else {
+      this.logger.success(`All ${successCount} files migrated successfully`);
+    }
+  }
+  async findMdxFiles(dir) {
+    const found = [];
+    const scan = async (currentDir) => {
+      const items = await readdir2(currentDir, { withFileTypes: true });
+      for (const item of items) {
+        const fullPath = join4(currentDir, item.name);
+        if (item.isDirectory()) {
+          if (!["node_modules", ".git", "dist", "build"].includes(item.name)) {
+            await scan(fullPath);
+          }
+        } else if (item.isFile() && item.name.endsWith(".mdx")) {
+          found.push(fullPath);
+        }
+      }
+    };
+    await scan(dir);
+    return found;
+  }
+  async migrateMdxFile(filePath) {
+    const content = await readFile(filePath, "utf-8");
+    try {
+      const converted = await this.convertMDXComponents(content, filePath);
+      const newFilePath = filePath.replace(/\.mdx$/, ".md");
+      await writeFile2(newFilePath, converted);
+      await rm2(filePath);
+      this.logger.file(`Migrated: ${relative(this.docsPath, filePath)}`);
+    } catch (error) {
+      const relativePath = relative(this.docsPath, filePath);
+      this.logger.warn(`Using fallback conversion for ${relativePath}`);
+      const fallbackContent = content.replace(/<[^>]*\/>/g, "").replace(/<[^>]*>.*?<\/[^>]*>/g, "").replace(/import\s+.*?from\s+['"][^'"]*['"];?\s*/g, "").replace(/\n\s*\n\s*\n/g, "\n\n").trim();
+      const newFilePath = filePath.replace(/\.mdx$/, ".md");
+      await writeFile2(newFilePath, fallbackContent);
+      await rm2(filePath);
+      this.logger.file(`Migrated (fallback): ${relativePath}`);
+      throw error;
+    }
+  }
+  async convertMDXComponents(content, filePath) {
+    try {
+      let hasFrontmatter = content.startsWith("---");
+      let frontmatter = "";
+      let body = content;
+      if (hasFrontmatter) {
+        const end = content.indexOf("---", 3);
+        if (end !== -1) {
+          frontmatter = content.substring(0, end + 3);
+          body = content.substring(end + 3);
+        }
+      } else {
+        frontmatter = "---\ntitle: TODO\n---";
+        hasFrontmatter = true;
+      }
+      const processor = createProcessor({ jsx: true, development: false });
+      const ast = await processor.parse(body);
+      const originalMdxString = body;
+      let title = "";
+      let description = "";
+      if (hasFrontmatter) {
+        const fm = frontmatter.replace(/^---\n/, "").replace(/\n---$/, "");
+        for (const line of fm.split("\n")) {
+          if (line.startsWith("title:")) {
+            title = line.replace("title:", "").trim();
+            title = title.replace(/^[\'\"`]|[\'\"`]$/g, "");
+            title = title.replace(/[\\`*_{}\[\]()#+\-!]/g, "\\$&");
+          } else if (line.startsWith("description:")) {
+            description = line.replace("description:", "").trim();
+            description = description.replace(/^[\'\"`]|[\'\"`]$/g, "");
+          }
+        }
+      }
+      await this.transformMintlifyComponents(ast, originalMdxString);
+      if (title || description) {
+        const nodes = [];
+        if (title) nodes.push({ type: "heading", depth: 1, children: [{ type: "text", value: title }] });
+        if (description)
+          nodes.push({
+            type: "containerDirective",
+            name: "subtitle",
+            children: [{ type: "text", value: description }]
+          });
+        ast.children = [...nodes, ...ast.children];
+      }
+      const markdown = remark().use(remarkDirective).use(remarkStringify, {
+        bullet: "-",
+        fences: true,
+        listItemIndent: "one",
+        incrementListMarker: true,
+        quote: '"',
+        emphasis: "*",
+        strong: "*",
+        tightDefinitions: true
+      }).stringify(ast).replace(/&#x20;/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\\\[/g, "[").replace(/\\\]/g, "]").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
+      return frontmatter + "\n\n" + markdown;
+    } catch (error) {
+      const relativePath = relative(this.docsPath, filePath);
+      if (this.options.verbose) {
+        this.logger.errorVerbose(error, `MDX transformation error in ${relativePath}`);
+      } else {
+        this.logger.warn(`Failed to transform MDX components in ${relativePath}, using fallback`);
+      }
+      throw error;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // AST transforms
+  // ---------------------------------------------------------------------------
+  convertLightDarkImage(node) {
+    const className = node.attributes?.find((a) => a.name === "className")?.value || "";
+    let src = node.attributes?.find((a) => a.name === "src")?.value || "";
+    const alt = node.attributes?.find((a) => a.name === "alt")?.value || "";
+    if (className.includes("dark:hidden") || className.includes("dark:block")) {
+      let colorScheme = "";
+      if (className.includes("dark:hidden")) colorScheme = "light";
+      else if (className.includes("dark:block")) colorScheme = "dark";
+      if (src.startsWith("/") && !src.startsWith("/public/") && !src.startsWith("http://") && !src.startsWith("https://")) {
+        src = `/public${src}`;
+      }
+      return { colorScheme, src, alt };
+    }
+    return null;
+  }
+  async transformMintlifyComponents(ast, originalMdxString) {
+    const includeMapping = {};
+    const transformNode = async (node) => {
+      if (!node) return null;
+      const processedChildren = [];
+      if (node.children) {
+        for (const child of node.children) {
+          const processed = await transformNode(child);
+          if (!processed) continue;
+          if (Array.isArray(processed)) processedChildren.push(...processed);
+          else processedChildren.push(processed);
+        }
+      }
+      if (node.type === "text" && node.value) {
+        node.value = node.value.replace(/&#x20;/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+      }
+      if (node.type === "mdxjsEsm") {
+        const importStatement = node.value || "";
+        const importMatch = importStatement.match(/import\s+(\w+)\s+from\s+["']([^"']+)["']/);
+        if (importMatch) {
+          const [, componentName, importPath] = importMatch;
+          let xydPath = importPath;
+          if (importPath.startsWith("./") || importPath.startsWith("/")) {
+            xydPath = importPath.replace(/^\.?\//, "~/").replace(/\.mdx$/, ".md");
+          }
+          includeMapping[componentName] = xydPath;
+          return null;
+        }
+        return { type: "html", value: `<!-- Import statement not supported: ${importStatement} -->` };
+      }
+      if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement" || node.type === "mdxFlowExpression") {
+        const componentName = node.name;
+        const children = processedChildren;
+        switch (componentName) {
+          case "img": {
+            const imageData = this.convertLightDarkImage(node);
+            if (imageData) {
+              return {
+                type: "html",
+                value: `<img src="${imageData.src}" alt="${imageData.alt}" data-color-scheme="${imageData.colorScheme}" />`
+              };
+            }
+            break;
+          }
+          case "Columns":
+          case "CardGroup": {
+            const colsAttr = node.attributes?.find((a) => a.name === "cols");
+            let cols = "2";
+            if (typeof colsAttr?.value === "string") cols = colsAttr.value;
+            else if (typeof colsAttr?.value?.value === "string") cols = colsAttr.value.value;
+            const listItems = children.map((child) => ({
+              type: "listItem",
+              children: [{ type: "paragraph", children: [child] }]
+            }));
+            const list = {
+              type: "list",
+              ordered: false,
+              children: [{ type: "listItem", children: listItems }]
+            };
+            return { type: "containerDirective", name: "grid", attributes: { cols }, children: [list] };
+          }
+          case "Card": {
+            const title = node.attributes?.find((a) => a.name === "title")?.value || "";
+            const href = node.attributes?.find((a) => a.name === "href")?.value || "";
+            const icon = node.attributes?.find((a) => a.name === "icon")?.value || "";
+            const iconType = node.attributes?.find((a) => a.name === "iconType")?.value || "";
+            const description = node.attributes?.find((a) => a.name === "description")?.value || "";
+            const imgSrc = node.attributes?.find((a) => a.name === "imgSrc")?.value || "";
+            const cardAttributes = { kind: "secondary" };
+            if (title) cardAttributes.title = title;
+            if (href) cardAttributes.href = href;
+            if (icon) cardAttributes.icon = icon;
+            if (iconType) cardAttributes.iconType = iconType;
+            if (description) cardAttributes.description = description;
+            if (imgSrc) cardAttributes.imgSrc = imgSrc;
+            return { type: "containerDirective", name: "guide-card", attributes: cardAttributes, children };
+          }
+          case "Frame": {
+            let pictureHtml = "<picture>\n";
+            if (node.children) {
+              for (const child of node.children) {
+                if (child.type === "mdxJsxFlowElement" && child.name === "img") {
+                  const imageData = this.convertLightDarkImage(child);
+                  if (!imageData) continue;
+                  pictureHtml += `  <img src="${imageData.src}" alt="${imageData.alt}" data-color-scheme="${imageData.colorScheme}" />
+`;
+                }
+              }
+            }
+            pictureHtml += "</picture>";
+            return { type: "html", value: pictureHtml };
+          }
+          case "Note":
+          case "Info":
+          case "Warning":
+          case "Tip":
+          case "Danger": {
+            let kind = void 0;
+            switch (componentName) {
+              case "Note":
+                kind = "note";
+                break;
+              case "Warning":
+                kind = "warning";
+                break;
+              case "Tip":
+                kind = "tip";
+                break;
+              case "Check":
+                kind = "check";
+                break;
+              case "Danger":
+                kind = "danger";
+                break;
+            }
+            return {
+              type: "containerDirective",
+              name: "callout",
+              attributes: { kind },
+              children: [{ type: "paragraph", children }]
+            };
+          }
+          case "Steps": {
+            return {
+              type: "containerDirective",
+              name: "steps",
+              attributes: { kind: "secondary" },
+              children: [{ type: "list", ordered: true, start: 1, children }]
+            };
+          }
+          case "Step": {
+            const stepTitle = node.attributes?.find((a) => a.name === "title")?.value || "";
+            const stepIcon = node.attributes?.find((a) => a.name === "icon")?.value || "";
+            const attrs = [];
+            if (stepIcon) attrs.push({ name: "icon", value: stepIcon });
+            if (stepTitle) attrs.push({ name: "title", value: stepTitle });
+            const listItemChildren = [];
+            if (attrs.length) listItemChildren.push({
+              type: "text",
+              value: `[${attrs.map((a) => `${a.name}="${a.value}"`).join(" ")}] `
+            });
+            listItemChildren.push(...children);
+            return { type: "listItem", children: [{ type: "paragraph", children: listItemChildren }] };
+          }
+          case "Tabs": {
+            return {
+              type: "containerDirective",
+              name: "tabs",
+              attributes: { kind: "secondary" },
+              children: [{ type: "list", ordered: true, start: 1, children }]
+            };
+          }
+          case "Tab": {
+            const tabTitle = node.attributes?.find((a) => a.name === "title")?.value || "";
+            const parts = [];
+            if (tabTitle) {
+              const typeValue = String(tabTitle).toLowerCase();
+              parts.push({ type: "text", value: `[${tabTitle}](type=${typeValue})` });
+              parts.push({ type: "text", value: "\n" });
+            }
+            parts.push(...children);
+            return { type: "listItem", children: [{ type: "paragraph", children: parts }] };
+          }
+          default: {
+            if (includeMapping[componentName]) {
+              return {
+                type: "paragraph",
+                children: [{ type: "text", value: `@include "${includeMapping[componentName]}"` }]
+              };
+            }
+            const textContent = children.filter((child) => child.type === "text" || child.type === "paragraph").map((child) => {
+              if (child.type === "text") return child.value;
+              if (child.type === "paragraph" && child.children) {
+                return child.children.filter((c) => c.type === "text").map((c) => c.value).join(" ");
+              }
+              return "";
+            }).join(" ").trim();
+            const comment = textContent ? `<!-- ${componentName}: ${textContent} -->` : `<!-- ${componentName} component not supported -->`;
+            return { type: "html", value: comment };
+          }
+        }
+      }
+      node.children = processedChildren;
+      return node;
+    };
+    const transformed = await transformNode(ast);
+    return transformed || { type: "root", children: [] };
+  }
+  // ---------------------------------------------------------------------------
+  // Small utilities (ported from original helpers)
+  // ---------------------------------------------------------------------------
+  hasNestedGroups(pages) {
+    for (const page of pages) {
+      if (typeof page === "object" && page.group) return true;
+    }
+    return false;
+  }
+  isFlatStructure(pages) {
+    const prefixes = /* @__PURE__ */ new Set();
+    let hasStringPages = false;
+    let hasGroupPages = false;
+    for (const page of pages) {
+      if (typeof page === "string") {
+        hasStringPages = true;
+        const parts = page.split("/");
+        if (parts.length > 1) prefixes.add(parts[0]);
+      } else if (typeof page === "object" && page.pages) {
+        hasGroupPages = true;
+        for (const nested of page.pages) {
+          if (typeof nested === "string") {
+            const parts = nested.split("/");
+            if (parts.length > 1) prefixes.add(parts[0]);
+          }
+        }
+      }
+    }
+    return prefixes.size > 1 || hasStringPages && hasGroupPages || prefixes.size === 1 && pages.some((p) => typeof p === "string" && !p.includes("/"));
+  }
+  findFirstPage(pages) {
+    for (const page of pages) {
+      if (typeof page === "string") return page;
+      else if (typeof page === "object" && page.pages) {
+        const first = this.findFirstPage(page.pages);
+        if (first) return first;
+      }
+    }
+    return null;
+  }
+  validateRoutePages(route, pages) {
+    if (!route) return true;
+    const check = (page) => {
+      if (typeof page === "string") return page.startsWith(route + "/") || page === route;
+      else if (typeof page === "object" && page.pages) return page.pages.every((nested) => check(nested));
+      return false;
+    };
+    return pages.every(check);
+  }
+};
+// ------ static helpers kept public-ish for unit reuse ------
+MintlifyMigrator.validMintlifyJsonFile = (fileName) => fileName === "docs.json" || fileName === "mint.json";
+
+// src/commands/migrateme/nextra/nextra.ts
+function nextraMigrator(docsPath) {
+  throw new Error("Nextra migration is not implemented yet");
+  console.log("Migrating Nextra repository...");
+}
+async function isNextra(docsPath, fileName) {
+  return false;
+  if (fileName === "nextra.config.js" || fileName === "nextra.config.ts") {
+    console.log("\u{1F50D} Nextra framework detected!");
+    return true;
+  }
+}
+
+// src/commands/migrateme/docusaururs/docusaururs.ts
+function docusaurusMigrator(docsPath) {
+  throw new Error("Docusaurus migration is not implemented yet");
+  console.log("Migrating Docusaurus repository...");
+}
+async function isDocusaurus(docsPath, fileName) {
+  return false;
+  if (fileName === "docusaurus.config.js" || fileName === "docusaurus.config.ts") {
+    console.log("\u{1F50D} Docusaurus framework detected!");
+    return true;
+  }
+}
+
+// src/commands/migrateme/vitepress/vitepress.ts
+function vitepressMigrator(docsPath) {
+  throw new Error("VitePress migration is not implemented yet");
+  console.log("Migrating VitePress repository...");
+}
+async function isVitepress(docsPath, fileName) {
+  return false;
+  if (fileName === "docs/.vitepress/config.js" || fileName === "docs/.vitepress/config.ts") {
+    console.log("\u{1F50D} VitePress framework detected!");
+    return true;
+  }
+}
+
+// src/commands/migrateme/migration.ts
+var execAsync = promisify3(exec3);
+async function migration(docsPath) {
+  console.log("Detecting framework in repository...");
+  try {
+    const files = await readdir3(docsPath, { withFileTypes: true });
+    for (const file of files) {
+      if (!file.isFile()) {
+        continue;
+      }
+      const fileNameLower = file.name.toLowerCase();
+      const framework = await detectFrameworkByFile(fileNameLower, docsPath);
+      if (framework) {
+        await frameworkMigration(framework, docsPath);
+        return;
+      }
+    }
+    console.log("\u274C No supported documentation framework detected in root directory");
+    console.log("\u{1F4CB} Supported frameworks: Mintlify, Nextra, Docusaurus, VuePress");
+  } catch (error) {
+    console.error("Error detecting framework:", error);
+  }
+}
+async function detectFrameworkByFile(fileName, docsPath) {
+  if (await isMintlify(docsPath, fileName)) {
+    return "mintlify" /* MINTLIFY */;
+  }
+  if (await isNextra(docsPath, fileName)) {
+    return "nextra" /* NEXTRA */;
+  }
+  if (await isDocusaurus(docsPath, fileName)) {
+    return "docusaurus" /* DOCUSAURUS */;
+  }
+  if (await isVitepress(docsPath, fileName)) {
+    return "vitepress" /* VITEPRESS */;
+  }
+  return null;
+}
+async function frameworkMigration(framework, docsPath, outDir = false) {
+  if (outDir) {
+    docsPath = await cloneDocsPath(docsPath, outDir);
+  }
+  switch (framework) {
+    case "mintlify" /* MINTLIFY */:
+      return await mintlifyMigrator(docsPath);
+    case "nextra" /* NEXTRA */:
+      return await nextraMigrator(docsPath);
+    case "docusaurus" /* DOCUSAURUS */:
+      return await docusaurusMigrator(docsPath);
+    case "vitepress" /* VITEPRESS */:
+      return await vitepressMigrator(docsPath);
+  }
+}
+async function cloneDocsPath(docsPath, outDir = true) {
+  if (typeof outDir === "boolean") {
+    outDir = `${docsPath}_${Math.random().toString(36).substring(2, 8)}`;
+  }
+  docsPath = await cloneDirectory(docsPath, outDir);
+  console.log(`Cloned docsPath to: ${docsPath}`);
+  return docsPath;
+}
+async function cloneDirectory(src, dest = "") {
+  if (existsSync2(dest)) {
+    await execAsync(`rm -rf "${dest}"`);
+  }
+  await execAsync(`cp -R "${src}" "${dest}"`);
+  return dest;
+}
+
+// src/commands/migrateme/migrateme.ts
+async function migrateme(resource, migratemeFlags, globalFlags) {
+  if (!resource || typeof resource !== "string") {
+    console.error("No resource provided");
+    return;
+  }
+  if (isGitHubRepo(resource)) {
+    await askForClean(migratemeFlags);
+    const extractDir = await downloadGitHubRepo(resource, migratemeFlags);
+    await migration(extractDir);
+    return;
+  }
+  const docsPath = resolveResourcePath(resource);
+  if (existsSync3(docsPath)) {
+    await askForStart();
+    await migration(docsPath);
+    return;
+  }
+  console.error("No support for this resource yet");
+}
+
+// src/commands/components.ts
+import colors2 from "picocolors";
+import { componentsInstall } from "@xyd-js/documan";
+async function components(args, flags) {
+  const subcommand = args[0];
+  if (subcommand === "install") {
+    const componentName = args[1];
+    const success = await componentsInstall(componentName);
+    if (!success) {
+      process.exit(1);
+    }
+  } else {
+    console.error(colors2.red(`Error: Unknown subcommand '${subcommand}'`));
+    console.log("Available subcommands: install");
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+async function cli(argv = process.argv.slice(2)) {
+  if (!prerequisites()) {
+    process.exit(1);
+  }
+  updateNotify();
+  process.env.XYD_CLI = "true";
+  const { globalFlags, commands } = parseArgs(argv);
+  if (globalFlags.help) {
+    return printHelp();
+  }
+  if (globalFlags.version) {
+    return console.log(cliSpec.version);
+  }
+  if (!globalFlags.verbose) {
+    console.debug = () => {
+    };
+  }
+  const globalCommand = commands[0] || "dev";
+  if (!cliSpec.commands[globalCommand]) {
+    console.error(`Unknown command: ${globalCommand}`);
+    printHelp();
+    process.exit(1);
+  }
+  const commandArgs = commands.slice(1);
+  switch (globalCommand) {
+    case "components":
+      await components(commandArgs, globalFlags);
+      break;
+    default:
+      await commands_exports[globalCommand](...commandArgs, globalFlags);
+  }
+}
+function prerequisites() {
+  const nodeVersion = process.versions.node;
+  if (semver.major(nodeVersion) < MIN_NODE_VERSION) {
+    console.warn(`\u26A0\uFE0F Node ${nodeVersion} is too old. xyd requires Node >= 22.`);
+    return;
+  }
+  return true;
+}
+function updateNotify() {
+  const packageJson2 = getPackageJson();
+  const notifier = updateNotifier({ pkg: packageJson2 });
+  notifier.notify();
+}
+
+// index.ts
+cli().then(
+  () => {
+    process.exit(0);
+  },
+  (error) => {
+    if (error) console.error(error);
+    process.exit(1);
+  }
+);