@ant-design/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2308 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command, Option } from "commander";
+
+// src/types.ts
+function localize(en, zh, lang) {
+  if (lang === "zh" && zh) return zh;
+  return en || "";
+}
+
+// src/data/loader.ts
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getDataPath() {
+  const probe = "v5.json";
+  const candidates = [
+    join(__dirname, "..", "data"),
+    // from dist/
+    join(__dirname, "..", "..", "data")
+    // from src/data/
+  ];
+  return candidates.find((p) => existsSync(join(p, probe))) ?? candidates[0];
+}
+function loadMetadata(majorVersion) {
+  const dataPath = join(getDataPath(), `${majorVersion}.json`);
+  try {
+    return JSON.parse(readFileSync(dataPath, "utf-8"));
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      process.stderr.write(`[antd-cli] Warning: data file may be corrupted: ${dataPath}
+`);
+    }
+    return {
+      version: majorVersion,
+      majorVersion,
+      components: []
+    };
+  }
+}
+function findComponent(store, name) {
+  return store.components.find(
+    (c) => c.name.toLowerCase() === name.toLowerCase()
+  );
+}
+function getAllComponentNames(store) {
+  return store.components.map((c) => c.name);
+}
+
+// src/data/version.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var FALLBACK_VERSION = "5.24.0";
+var FALLBACK_MAJOR = "v5";
+function detectVersion(flagVersion) {
+  if (flagVersion) {
+    return {
+      version: flagVersion,
+      majorVersion: toMajor(flagVersion),
+      source: "flag"
+    };
+  }
+  const nmPath = join2(process.cwd(), "node_modules", "antd", "package.json");
+  if (existsSync2(nmPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(nmPath, "utf-8"));
+      if (pkg.version) {
+        return {
+          version: pkg.version,
+          majorVersion: toMajor(pkg.version),
+          source: "node_modules"
+        };
+      }
+    } catch {
+    }
+  }
+  const pkgPath = join2(process.cwd(), "package.json");
+  if (existsSync2(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      const depVersion = pkg.dependencies?.antd || pkg.devDependencies?.antd || pkg.peerDependencies?.antd;
+      if (depVersion) {
+        const cleaned = depVersion.replace(/[\^~>=<\s]/g, "");
+        return {
+          version: cleaned,
+          majorVersion: toMajor(cleaned),
+          source: "package.json"
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    version: FALLBACK_VERSION,
+    majorVersion: FALLBACK_MAJOR,
+    source: "fallback"
+  };
+}
+function toMajor(version) {
+  const major = version.split(".")[0];
+  return `v${major}`;
+}
+function compare(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const na = pa[i] || 0;
+    const nb = pb[i] || 0;
+    if (na < nb) return -1;
+    if (na > nb) return 1;
+  }
+  return 0;
+}
+
+// src/output/formatter.ts
+function formatOutput(data, format) {
+  switch (format) {
+    case "json":
+      return JSON.stringify(data, null, 2);
+    case "markdown":
+      return formatAsMarkdown(data);
+    case "text":
+    default:
+      return formatAsText(data);
+  }
+}
+function formatAsText(data) {
+  if (typeof data === "string") return data;
+  if (Array.isArray(data)) return data.map((item) => formatAsText(item)).join("\n");
+  if (typeof data === "object" && data !== null) {
+    return Object.entries(data).map(([key, value]) => {
+      if (Array.isArray(value)) {
+        return `${key}:
+${value.map((v) => `  ${formatAsText(v)}`).join("\n")}`;
+      }
+      return `${key}: ${value}`;
+    }).join("\n");
+  }
+  return String(data);
+}
+function formatAsMarkdown(data) {
+  if (typeof data === "string") return data;
+  if (typeof data === "object" && data !== null) {
+    return "```json\n" + JSON.stringify(data, null, 2) + "\n```";
+  }
+  return String(data);
+}
+function formatTable(headers, rows, format) {
+  if (format === "json") {
+    return JSON.stringify(
+      rows.map((row) => {
+        const obj = {};
+        headers.forEach((h, i) => {
+          obj[h] = row[i];
+        });
+        return obj;
+      }),
+      null,
+      2
+    );
+  }
+  if (format === "markdown") {
+    const escPipe = (s) => s.replace(/\|/g, "\\|");
+    const headerLine2 = "| " + headers.map(escPipe).join(" | ") + " |";
+    const separator2 = "| " + headers.map(() => "---").join(" | ") + " |";
+    const bodyLines2 = rows.map((row) => "| " + row.map(escPipe).join(" | ") + " |");
+    return [headerLine2, separator2, ...bodyLines2].join("\n");
+  }
+  const colWidths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || "").length))
+  );
+  const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join("  ");
+  const separator = colWidths.map((w) => "-".repeat(w)).join("  ");
+  const bodyLines = rows.map(
+    (row) => row.map((cell, i) => (cell || "").padEnd(colWidths[i])).join("  ")
+  );
+  return [headerLine, separator, ...bodyLines].join("\n");
+}
+function output(data, format) {
+  console.log(formatOutput(data, format));
+}
+
+// src/commands/list.ts
+function registerListCommand(program2) {
+  program2.command("list").description("List all components with descriptions and categories").action(() => {
+    const opts = program2.opts();
+    const versionInfo = detectVersion(opts.version);
+    const store = loadMetadata(versionInfo.majorVersion);
+    const lang = opts.lang;
+    if (store.components.length === 0) {
+      console.log("No component data available.");
+      return;
+    }
+    if (opts.format === "json") {
+      const data = store.components.map((c) => ({
+        name: c.name,
+        category: localize(c.category, c.categoryZh, lang),
+        description: localize(c.description, c.descriptionZh, lang)
+      }));
+      output(data, "json");
+      return;
+    }
+    const categories = /* @__PURE__ */ new Map();
+    for (const comp of store.components) {
+      const cat = localize(comp.category, comp.categoryZh, lang) || "Other";
+      if (!categories.has(cat)) categories.set(cat, []);
+      categories.get(cat).push(comp);
+    }
+    if (opts.format === "markdown") {
+      const lines = [`# antd Components (${versionInfo.version})`, ""];
+      for (const [category, components] of categories) {
+        lines.push(`## ${category}`, "");
+        for (const comp of components) {
+          const desc = localize(comp.description, comp.descriptionZh, lang);
+          lines.push(`- **${comp.name}** \u2014 ${desc}`);
+        }
+        lines.push("");
+      }
+      console.log(lines.join("\n"));
+      return;
+    }
+    const headers = ["Component", "Category", "Description"];
+    const rows = store.components.map((c) => [
+      c.name,
+      localize(c.category, c.categoryZh, lang),
+      localize(c.description, c.descriptionZh, lang)
+    ]);
+    console.log(formatTable(headers, rows, "text"));
+  });
+}
+
+// src/output/error.ts
+var ErrorCodes = {
+  COMPONENT_NOT_FOUND: "COMPONENT_NOT_FOUND",
+  VERSION_NOT_FOUND: "VERSION_NOT_FOUND",
+  NO_PROJECT_DETECTED: "NO_PROJECT_DETECTED",
+  METADATA_FETCH_FAILED: "METADATA_FETCH_FAILED",
+  UNSUPPORTED_VERSION_FEATURE: "UNSUPPORTED_VERSION_FEATURE",
+  DEMO_NOT_FOUND: "DEMO_NOT_FOUND",
+  INVALID_ARGUMENT: "INVALID_ARGUMENT"
+};
+function createError(code, message, suggestion) {
+  return { error: true, code, message, suggestion };
+}
+function printError(err, format) {
+  if (format === "json") {
+    console.error(JSON.stringify(err, null, 2));
+  } else {
+    console.error(`Error: ${err.message}`);
+    if (err.suggestion) {
+      console.error(`Suggestion: ${err.suggestion}`);
+    }
+  }
+}
+function fuzzyMatch(input, candidates) {
+  if (candidates.length === 0) return void 0;
+  const lower = input.toLowerCase();
+  const exact = candidates.find((c) => c.toLowerCase() === lower);
+  if (exact) return exact;
+  const prefix = candidates.find((c) => c.toLowerCase().startsWith(lower));
+  if (prefix) return prefix;
+  const contains = candidates.find((c) => c.toLowerCase().includes(lower));
+  if (contains) return contains;
+  let best;
+  let bestDist = Infinity;
+  for (const candidate of candidates) {
+    const dist = levenshtein(lower, candidate.toLowerCase());
+    if (dist < bestDist && dist <= 3) {
+      bestDist = dist;
+      best = candidate;
+    }
+  }
+  return best;
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+
+// src/commands/info.ts
+function registerInfoCommand(program2) {
+  program2.command("info <component>").description("Query component API: props, type definitions, default values").action((component) => {
+    const opts = program2.opts();
+    const lang = opts.lang;
+    const versionInfo = detectVersion(opts.version);
+    const store = loadMetadata(versionInfo.majorVersion);
+    const comp = findComponent(store, component);
+    if (!comp) {
+      const names = getAllComponentNames(store);
+      const suggestion = fuzzyMatch(component, names);
+      const err = createError(
+        ErrorCodes.COMPONENT_NOT_FOUND,
+        `Component '${component}' not found`,
+        suggestion ? `Did you mean '${suggestion}'?` : void 0
+      );
+      printError(err, opts.format);
+      process.exitCode = 1;
+      return;
+    }
+    const desc = localize(comp.description, comp.descriptionZh, lang);
+    const whenToUse = localize(comp.whenToUse, comp.whenToUseZh, lang);
+    if (opts.format === "json") {
+      if (opts.detail) {
+        output(
+          {
+            name: comp.name,
+            description: desc,
+            whenToUse: whenToUse || "",
+            props: comp.props.map((p) => ({
+              ...p,
+              description: localize(p.description, p.descriptionZh, lang)
+            })),
+            methods: comp.methods || [],
+            related: comp.related || [],
+            faq: comp.faq || []
+          },
+          "json"
+        );
+      } else {
+        output(
+          {
+            name: comp.name,
+            description: desc,
+            props: comp.props.map((p) => ({
+              name: p.name,
+              type: p.type,
+              default: p.default
+            }))
+          },
+          "json"
+        );
+      }
+      return;
+    }
+    console.log(`${comp.name} \u2014 ${desc}`);
+    if (opts.detail && whenToUse) {
+      console.log(`
+When to use: ${whenToUse}`);
+    }
+    console.log("");
+    const headers = opts.detail ? ["Property", "Type", "Default", "Description"] : ["Property", "Type", "Default"];
+    const rows = comp.props.map(
+      (p) => opts.detail ? [p.name, p.type, p.default, localize(p.description, p.descriptionZh, lang) || "-"] : [p.name, p.type, p.default]
+    );
+    console.log(formatTable(headers, rows, opts.format === "markdown" ? "markdown" : "text"));
+    if (opts.detail && comp.related && comp.related.length > 0) {
+      console.log(`
+Related: ${comp.related.join(", ")}`);
+    }
+  });
+}
+
+// src/commands/demo.ts
+function registerDemoCommand(program2) {
+  program2.command("demo <component> [name]").description("Get demo source code for a component").action((component, name) => {
+    const opts = program2.opts();
+    const versionInfo = detectVersion(opts.version);
+    const store = loadMetadata(versionInfo.majorVersion);
+    const comp = findComponent(store, component);
+    if (!comp) {
+      const names = getAllComponentNames(store);
+      const suggestion = fuzzyMatch(component, names);
+      const err = createError(
+        ErrorCodes.COMPONENT_NOT_FOUND,
+        `Component '${component}' not found`,
+        suggestion ? `Did you mean '${suggestion}'?` : void 0
+      );
+      printError(err, opts.format);
+      process.exitCode = 1;
+      return;
+    }
+    const demos = comp.demos || [];
+    if (!name) {
+      if (opts.format === "json") {
+        output(
+          {
+            component: comp.name,
+            demos: demos.map((d) => ({
+              name: d.name,
+              title: d.title,
+              description: d.description
+            }))
+          },
+          "json"
+        );
+      } else {
+        console.log(`${comp.name} Demos:`);
+        console.log("");
+        for (const demo2 of demos) {
+          console.log(`  ${demo2.name} \u2014 ${demo2.title}`);
+          console.log(`    ${demo2.description}`);
+        }
+        if (demos.length === 0) {
+          console.log("  No demos available.");
+        }
+      }
+      return;
+    }
+    const demo = demos.find((d) => d.name.toLowerCase() === name.toLowerCase());
+    if (!demo) {
+      const demoNames = demos.map((d) => d.name);
+      const suggestion = fuzzyMatch(name, demoNames);
+      const err = createError(
+        ErrorCodes.DEMO_NOT_FOUND,
+        `Demo '${name}' not found for ${comp.name}`,
+        suggestion ? `Did you mean '${suggestion}'?` : `Available demos: ${demoNames.join(", ") || "none"}`
+      );
+      printError(err, opts.format);
+      process.exitCode = 1;
+      return;
+    }
+    if (opts.format === "json") {
+      output(
+        {
+          component: comp.name,
+          demo: demo.name,
+          title: demo.title,
+          description: demo.description,
+          code: demo.code
+        },
+        "json"
+      );
+    } else {
+      console.log(`${comp.name} / ${demo.title}`);
+      console.log(`${demo.description}`);
+      console.log("");
+      console.log(demo.code);
+    }
+  });
+}
+
+// src/commands/token.ts
+function registerTokenCommand(program2) {
+  program2.command("token [component]").description("Query Design Tokens (global or component-level)").action((component) => {
+    const opts = program2.opts();
+    const versionInfo = detectVersion(opts.version);
+    if (versionInfo.majorVersion === "v4") {
+      const err = createError(
+        ErrorCodes.UNSUPPORTED_VERSION_FEATURE,
+        "Design Token system is not available in antd v4",
+        "Upgrade to antd v5+ to use Design Tokens"
+      );
+      printError(err, opts.format);
+      process.exitCode = 1;
+      return;
+    }
+    const store = loadMetadata(versionInfo.majorVersion);
+    if (!component) {
+      const globalTokens = store.globalTokens || [];
+      if (globalTokens.length === 0) {
+        console.log("No global token data available.");
+        return;
+      }
+      if (opts.format === "json") {
+        output({ tokens: globalTokens }, "json");
+        return;
+      }
+      console.log("Global Design Tokens:");
+      console.log("");
+      const headers2 = ["Token", "Type", "Default", "Description"];
+      const rows2 = globalTokens.map((t) => [t.name, t.type, t.default, t.description || "-"]);
+      console.log(formatTable(headers2, rows2, opts.format === "markdown" ? "markdown" : "text"));
+      return;
+    }
+    const comp = findComponent(store, component);
+    if (!comp) {
+      const names = getAllComponentNames(store);
+      const suggestion = fuzzyMatch(component, names);
+      const err = createError(
+        ErrorCodes.COMPONENT_NOT_FOUND,
+        `Component '${component}' not found`,
+        suggestion ? `Did you mean '${suggestion}'?` : void 0
+      );
+      printError(err, opts.format);
+      process.exitCode = 1;
+      return;
+    }
+    const tokens = comp.tokens || [];
+    if (tokens.length === 0) {
+      console.log(`No component tokens available for ${comp.name}.`);
+      return;
+    }
+    if (opts.format === "json") {
+      output({ component: comp.name, tokens }, "json");
+      return;
+    }
+    console.log(`${comp.name} Component Tokens:`);
+    console.log("");
+    const headers = ["Token", "Type", "Default"];
+    const rows = tokens.map((t) => [t.name, t.type, t.default]);
+    console.log(formatTable(headers, rows, opts.format === "markdown" ? "markdown" : "text"));
+  });
+}
+
+// src/commands/semantic.ts
+function registerSemanticCommand(program2) {
+  program2.command("semantic <component>").description("Query the semantic customization structure of a component").action((component) => {
+    const opts = program2.opts();
+    const versionInfo = detectVersion(opts.version);
+    const store = loadMetadata(versionInfo.majorVersion);
+    const comp = findComponent(store, component);
+    if (!comp) {
+      const names = getAllComponentNames(store);
+      const suggestion = fuzzyMatch(component, names);
+      const err = createError(
+        ErrorCodes.COMPONENT_NOT_FOUND,
+        `Component '${component}' not found`,
+        suggestion ? `Did you mean '${suggestion}'?` : void 0
+      );
+      printError(err, opts.format);
+      process.exitCode = 1;
+      return;
+    }
+    const structure = comp.semanticStructure || [];
+    if (structure.length === 0) {
+      console.log(`No semantic structure data available for ${comp.name}.`);
+      return;
+    }
+    if (opts.format === "json") {
+      output({ name: comp.name, semanticStructure: structure }, "json");
+      return;
+    }
+    console.log(`${comp.name} Semantic Structure:`);
+    for (let i = 0; i < structure.length; i++) {
+      const prefix = i === structure.length - 1 ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+      console.log(`${prefix} ${structure[i].key}         # ${structure[i].description}`);
+    }
+    console.log("");
+    console.log("Usage:");
+    console.log(`  <${comp.name} classNames={{ ${structure[0]?.key}: 'my-${structure[0]?.key}' }} />`);
+    console.log(`  <${comp.name} styles={{ ${structure[0]?.key}: { background: '#fff' } }} />`);
+  });
+}
+
+// src/commands/diff.ts
+function parseVersionRange(version) {
+  if (version.includes("..")) {
+    const [from, to] = version.split("..");
+    return { from, to };
+  }
+  return { exact: version };
+}
+function filterEntries(changelog, versionArg) {
+  if (!versionArg) return changelog.slice(0, 5);
+  const parsed = parseVersionRange(versionArg);
+  if ("exact" in parsed) {
+    return changelog.filter((e) => e.version === parsed.exact);
+  }
+  return changelog.filter(
+    (e) => compare(e.version, parsed.from) >= 0 && compare(e.version, parsed.to) <= 0
+  );
+}
+var EMOJI_MAP = {
+  feature: "\u{1F195}",
+  fix: "\u{1F41E}",
+  style: "\u{1F484}",
+  deprecation: "\u{1F5D1}",
+  breaking: "\u{1F525}",
+  other: "\u{1F6E0}"
+};
+function printChangelog(entries, format, versionArg) {
+  if (format === "json") {
+    output(versionArg ? entries : { latest: entries }, "json");
+    return;
+  }
+  for (const entry of entries) {
+    console.log(`## ${entry.version} (${entry.date})`);
+    console.log("");
+    for (const change of entry.changes) {
+      const emoji = EMOJI_MAP[change.type] || "\u2022";
+      console.log(`  ${emoji} ${change.component} ${change.description}`);
+    }
+    console.log("");
+  }
+}
+function toMajor2(version) {
+  return `v${version.split(".")[0]}`;
+}
+function diffProps(oldProps, newProps) {
+  const oldMap = new Map(oldProps.map((p) => [p.name, p]));
+  const newMap = new Map(newProps.map((p) => [p.name, p]));
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [name, prop] of newMap) {
+    if (!oldMap.has(name)) {
+      added.push({ name, type: prop.type });
+    } else {
+      const oldProp = oldMap.get(name);
+      if (oldProp.type !== prop.type) {
+        changed.push({ name, change: `${oldProp.type} \u2192 ${prop.type}` });
+      }
+    }
+  }
+  for (const [name, prop] of oldMap) {
+    if (!newMap.has(name)) {
+      const possibleRename = [...newMap.values()].find(
+        (p) => p.type === prop.type && !oldMap.has(p.name)
+      );
+      removed.push({ name, type: prop.type, replacement: possibleRename?.name });
+    }
+  }
+  return { added, removed, changed };
+}
+function runApiDiff(v1, v2, component, opts) {
+  const major1 = toMajor2(v1);
+  const major2 = toMajor2(v2);
+  const store1 = loadMetadata(major1);
+  const store2 = loadMetadata(major2);
+  if (store1.components.length === 0) {
+    printError(createError(ErrorCodes.VERSION_NOT_FOUND, `No data available for version ${v1} (${major1})`), opts.format);
+    process.exitCode = 1;
+    return;
+  }
+  if (store2.components.length === 0) {
+    printError(createError(ErrorCodes.VERSION_NOT_FOUND, `No data available for version ${v2} (${major2})`), opts.format);
+    process.exitCode = 1;
+    return;
+  }
+  const componentsToCompare = component ? [component] : [.../* @__PURE__ */ new Set([...getAllComponentNames(store1), ...getAllComponentNames(store2)])];
+  if (component) {
+    const c1 = findComponent(store1, component);
+    const c2 = findComponent(store2, component);
+    if (!c1 && !c2) {
+      const allNames = [.../* @__PURE__ */ new Set([...getAllComponentNames(store1), ...getAllComponentNames(store2)])];
+      const suggestion = fuzzyMatch(component, allNames);
+      printError(
+        createError(ErrorCodes.COMPONENT_NOT_FOUND, `Component '${component}' not found in either version`, suggestion ? `Did you mean '${suggestion}'?` : void 0),
+        opts.format
+      );
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const diffs = [];
+  for (const name of componentsToCompare) {
+    const c1 = findComponent(store1, name);
+    const c2 = findComponent(store2, name);
+    if (!c1 && c2) {
+      diffs.push({ component: name, added: c2.props.map((p) => ({ name: p.name, type: p.type })), removed: [], changed: [] });
+    } else if (c1 && !c2) {
+      diffs.push({ component: name, added: [], removed: c1.props.map((p) => ({ name: p.name, type: p.type })), changed: [] });
+    } else if (c1 && c2) {
+      const { added, removed, changed } = diffProps(c1.props, c2.props);
+      if (added.length > 0 || removed.length > 0 || changed.length > 0) {
+        diffs.push({ component: name, added, removed, changed });
+      }
+    }
+  }
+  if (opts.format === "json") {
+    const result = component && diffs.length > 0 ? { from: v1, to: v2, ...diffs[0] } : { from: v1, to: v2, diffs };
+    output(result, "json");
+    return;
+  }
+  if (diffs.length === 0) {
+    console.log(`No API differences found between ${v1} and ${v2}.`);
+    return;
+  }
+  console.log(`API Diff: ${v1} \u2192 ${v2}`);
+  console.log("");
+  for (const diff of diffs) {
+    console.log(`  ${diff.component}:`);
+    for (const p of diff.added) console.log(`    + ${p.name}: ${p.type}`);
+    for (const p of diff.removed) {
+      const note = p.replacement ? ` (replaced by ${p.replacement})` : "";
+      console.log(`    - ${p.name}: ${p.type}${note}`);
+    }
+    for (const p of diff.changed) console.log(`    ~ ${p.name}: ${p.change}`);
+    console.log("");
+  }
+}
+function registerChangelogCommand(program2) {
+  program2.command("changelog [v1] [v2] [component]").description("Query changelog or compare API differences between versions").action((v1, v2, component) => {
+    const opts = program2.opts();
+    const isChangelogMode = !v2 || v1 && v1.includes("..");
+    if (isChangelogMode) {
+      const v1ForDetect = v1?.includes("..") ? v1.split("..")[0] : v1;
+      const versionForDetect = opts.version ?? (v1ForDetect && /^\d+\.\d+\.\d+$/.test(v1ForDetect) ? v1ForDetect : void 0);
+      const versionInfo = detectVersion(versionForDetect);
+      const store = loadMetadata(versionInfo.majorVersion);
+      const changelog = store.changelog || [];
+      if (changelog.length === 0) {
+        console.log("No changelog data available.");
+        return;
+      }
+      const entries = filterEntries(changelog, v1);
+      if (entries.length === 0) {
+        const err = createError(
+          ErrorCodes.VERSION_NOT_FOUND,
+          `No changelog entries found for "${v1}"`,
+          `Available versions: ${changelog.map((e) => e.version).join(", ")}`
+        );
+        printError(err, opts.format);
+        process.exitCode = 1;
+        return;
+      }
+      printChangelog(entries, opts.format, v1);
+    } else {
+      if (compare(v1, v2) > 0) {
+        const err = createError(
+          ErrorCodes.INVALID_ARGUMENT,
+          `Version order is invalid: "${v1}" is newer than "${v2}"`,
+          `Did you mean: antd changelog ${v2} ${v1}${component ? " " + component : ""}?`
+        );
+        printError(err, opts.format);
+        process.exitCode = 1;
+        return;
+      }
+      runApiDiff(v1, v2, component, opts);
+    }
+  });
+}
+
+// src/commands/doctor.ts
+import { readFileSync as readFileSync4, readdirSync as readdirSync2 } from "fs";
+import { join as join4 } from "path";
+
+// src/utils/scan.ts
+import { readFileSync as readFileSync3, readdirSync, statSync } from "fs";
+import { join as join3, extname } from "path";
+var SCAN_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".umi"]);
+var ANTD_IMPORT_RE = /import\s+\{([^}]+)\}\s+from\s+['"]antd(?:\/[^'"]*)?['"]/g;
+function collectFiles(dir) {
+  const files = [];
+  try {
+    const stat = statSync(dir);
+    if (stat.isFile()) return [dir];
+  } catch {
+    return [];
+  }
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const fullPath = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...collectFiles(fullPath));
+      } else if (SCAN_EXTENSIONS.has(extname(entry.name))) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function parseAntdImports(content) {
+  const names = [];
+  ANTD_IMPORT_RE.lastIndex = 0;
+  let match;
+  while ((match = ANTD_IMPORT_RE.exec(content)) !== null) {
+    const parsed = match[1].split(",").map((n) => n.trim()).filter(Boolean);
+    names.push(...parsed);
+  }
+  return names;
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/doctor.ts
+function buildContext(cwd) {
+  const antdPkg = readJson(join4(cwd, "node_modules", "antd", "package.json"));
+  const antdMajor = antdPkg ? parseInt(antdPkg.version.split(".")[0], 10) : 0;
+  const projectPkg = readJson(join4(cwd, "package.json"));
+  const reactPkg = readJson(join4(cwd, "node_modules", "react", "package.json"));
+  return { cwd, antdPkg, antdMajor, projectPkg, reactPkg };
+}
+function checkAntdInstalled(ctx) {
+  if (!ctx.antdPkg) {
+    return {
+      name: "antd-installed",
+      status: "fail",
+      severity: "error",
+      message: "antd is not installed in node_modules",
+      suggestion: "Run `npm install antd` or `yarn add antd`"
+    };
+  }
+  return {
+    name: "antd-installed",
+    status: "pass",
+    message: `antd ${ctx.antdPkg.version || "unknown"} is installed`
+  };
+}
+function checkReactCompat(ctx) {
+  if (!ctx.antdPkg || !ctx.reactPkg) {
+    return {
+      name: "react-compat",
+      status: "warn",
+      severity: "warning",
+      message: "Cannot verify React compatibility \u2014 antd or react not found in node_modules"
+    };
+  }
+  const reactMajor = parseInt(ctx.reactPkg.version.split(".")[0], 10);
+  if (ctx.antdMajor >= 5 && reactMajor < 18) {
+    return {
+      name: "react-compat",
+      status: "fail",
+      severity: "error",
+      message: `React ${ctx.reactPkg.version} may not be compatible with antd ${ctx.antdPkg.version}`,
+      suggestion: "antd 5.x requires React 18+. Consider upgrading React."
+    };
+  }
+  return {
+    name: "react-compat",
+    status: "pass",
+    message: `React ${ctx.reactPkg.version} is compatible with antd ${ctx.antdPkg.version}`
+  };
+}
+function checkDuplicateInstall(ctx) {
+  const versions = [];
+  if (ctx.antdPkg?.version) versions.push(ctx.antdPkg.version);
+  const nmDir = join4(ctx.cwd, "node_modules");
+  try {
+    const entries = readdirSync2(nmDir);
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "antd") continue;
+      const nestedPkg = readJson(join4(nmDir, entry, "node_modules", "antd", "package.json"));
+      if (nestedPkg?.version && !versions.includes(nestedPkg.version)) {
+        versions.push(nestedPkg.version);
+      }
+    }
+  } catch {
+  }
+  if (versions.length > 1) {
+    return {
+      name: "duplicate-install",
+      status: "fail",
+      severity: "error",
+      message: `Found ${versions.length} antd installations: ${versions.join(", ")}`,
+      suggestion: "Run `npm dedupe` or check your dependency tree"
+    };
+  }
+  return {
+    name: "duplicate-install",
+    status: "pass",
+    message: "No duplicate antd installations detected"
+  };
+}
+function checkThemeConfig(ctx) {
+  if (ctx.antdMajor >= 5) {
+    const lessOverrides = readJson(join4(ctx.cwd, "theme", "antd.less"));
+    const modifyVars = ctx.projectPkg?.theme;
+    if (lessOverrides !== null || modifyVars) {
+      return {
+        name: "theme-config",
+        status: "warn",
+        severity: "warning",
+        message: "Found Less-based theme customization, but antd v5+ uses Design Tokens",
+        suggestion: "Migrate Less variables to ConfigProvider theme tokens. See https://ant.design/docs/react/migrate-less-variables"
+      };
+    }
+  }
+  return {
+    name: "theme-config",
+    status: "pass",
+    message: "No theme configuration issues detected"
+  };
+}
+function checkBabelPlugins(ctx) {
+  const babelConfigs = [".babelrc", "babel.config.js", "babel.config.json"];
+  let hasBabelPluginImport = false;
+  for (const configName of babelConfigs) {
+    try {
+      const content = readFileSync4(join4(ctx.cwd, configName), "utf-8");
+      if (content.includes("babel-plugin-import") || content.includes("import, { libraryName")) {
+        hasBabelPluginImport = true;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!hasBabelPluginImport && ctx.projectPkg?.babel) {
+    const babelStr = JSON.stringify(ctx.projectPkg.babel);
+    if (babelStr.includes("babel-plugin-import")) {
+      hasBabelPluginImport = true;
+    }
+  }
+  if (hasBabelPluginImport && ctx.antdMajor >= 5) {
+    return {
+      name: "babel-plugin",
+      status: "warn",
+      severity: "warning",
+      message: "babel-plugin-import is configured but not needed for antd v5+",
+      suggestion: "antd v5+ supports tree-shaking natively. Remove babel-plugin-import for antd to reduce build complexity."
+    };
+  }
+  return {
+    name: "babel-plugin",
+    status: "pass",
+    message: "No problematic Babel/webpack antd plugins detected"
+  };
+}
+function checkCssInJs(ctx) {
+  const cssinjs = readJson(join4(ctx.cwd, "node_modules", "@ant-design", "cssinjs", "package.json"));
+  if (!cssinjs) {
+    return {
+      name: "cssinjs",
+      status: "warn",
+      severity: "warning",
+      message: "No @ant-design/cssinjs found, SSR style extraction will not work",
+      suggestion: "Install @ant-design/cssinjs if you need SSR support"
+    };
+  }
+  return {
+    name: "cssinjs",
+    status: "pass",
+    message: "@ant-design/cssinjs is installed"
+  };
+}
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Diagnose project-level antd configuration issues").action(() => {
+    const opts = program2.opts();
+    const ctx = buildContext(process.cwd());
+    const checks = [
+      checkAntdInstalled(ctx),
+      checkReactCompat(ctx),
+      checkDuplicateInstall(ctx),
+      checkThemeConfig(ctx),
+      checkBabelPlugins(ctx),
+      checkCssInJs(ctx)
+    ];
+    const summary = {
+      pass: checks.filter((c) => c.status === "pass").length,
+      warn: checks.filter((c) => c.status === "warn").length,
+      fail: checks.filter((c) => c.status === "fail").length
+    };
+    if (opts.format === "json") {
+      output({ checks, summary }, "json");
+      return;
+    }
+    const ICONS = { pass: "\u2713", warn: "\u26A0", fail: "\u2717" };
+    console.log("antd Doctor\n");
+    for (const check of checks) {
+      const icon = ICONS[check.status];
+      console.log(`  ${icon} [${check.name}] ${check.message}`);
+      if (check.suggestion) {
+        console.log(`    \u2192 ${check.suggestion}`);
+      }
+    }
+    console.log("");
+    console.log(`Summary: ${summary.pass} passed, ${summary.warn} warnings, ${summary.fail} failed`);
+  });
+}
+
+// src/commands/usage.ts
+import { readFileSync as readFileSync5 } from "fs";
+var SUB_COMPONENT_RE = /\b(\w+)\.(\w+)\b/g;
+function scanFile(filePath) {
+  const result = /* @__PURE__ */ new Map();
+  let content;
+  try {
+    content = readFileSync5(filePath, "utf-8");
+  } catch {
+    return result;
+  }
+  const importedNames = parseAntdImports(content);
+  for (const name of importedNames) {
+    if (!result.has(name)) {
+      result.set(name, { count: 0, subComponents: /* @__PURE__ */ new Map() });
+    }
+    result.get(name).count++;
+  }
+  SUB_COMPONENT_RE.lastIndex = 0;
+  let match;
+  while ((match = SUB_COMPONENT_RE.exec(content)) !== null) {
+    const [, parent, child] = match;
+    if (importedNames.includes(parent)) {
+      const entry = result.get(parent);
+      const subKey = `${parent}.${child}`;
+      entry.subComponents.set(subKey, (entry.subComponents.get(subKey) || 0) + 1);
+    }
+  }
+  return result;
+}
+function registerUsageCommand(program2) {
+  program2.command("usage [dir]").description("Scan project for antd component/API usage statistics").action((dir) => {
+    const opts = program2.opts();
+    const targetDir = dir || ".";
+    const files = collectFiles(targetDir);
+    const aggregated = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const fileUsage = scanFile(file);
+      for (const [name, data] of fileUsage) {
+        if (!aggregated.has(name)) {
+          aggregated.set(name, { imports: 0, files: /* @__PURE__ */ new Set(), subComponents: /* @__PURE__ */ new Map() });
+        }
+        const agg = aggregated.get(name);
+        agg.imports += data.count;
+        agg.files.add(file);
+        for (const [sub, count] of data.subComponents) {
+          agg.subComponents.set(sub, (agg.subComponents.get(sub) || 0) + count);
+        }
+      }
+    }
+    const components = [...aggregated.entries()].sort((a, b) => b[1].imports - a[1].imports).map(([name, data]) => {
+      const usage = {
+        name,
+        imports: data.imports,
+        files: [...data.files]
+      };
+      if (data.subComponents.size > 0) {
+        usage.subComponents = Object.fromEntries(data.subComponents);
+      }
+      return usage;
+    });
+    const totalImports = components.reduce((sum, c) => sum + c.imports, 0);
+    if (opts.format === "json") {
+      output({
+        scanned: files.length,
+        components,
+        summary: { totalComponents: components.length, totalImports }
+      }, "json");
+      return;
+    }
+    console.log(`Scanned ${files.length} files in ${targetDir}
+`);
+    if (components.length === 0) {
+      console.log("No antd imports found.");
+      return;
+    }
+    for (const comp of components) {
+      console.log(`  ${comp.name} \u2014 ${comp.imports} imports across ${comp.files.length} files`);
+      if (comp.subComponents) {
+        for (const [sub, count] of Object.entries(comp.subComponents)) {
+          console.log(`    ${sub}: ${count} usages`);
+        }
+      }
+    }
+    console.log(`
+Total: ${components.length} components, ${totalImports} imports`);
+  });
+}
+
+// src/commands/lint.ts
+import { readFileSync as readFileSync6 } from "fs";
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getDeprecatedProps(store) {
+  const result = /* @__PURE__ */ new Map();
+  for (const comp of store.components) {
+    const deprecated = comp.props.filter((p) => p.deprecated);
+    if (deprecated.length > 0) {
+      result.set(comp.name, deprecated.map((p) => ({
+        prop: p.name,
+        since: typeof p.deprecated === "string" ? p.deprecated : "unknown",
+        message: `\`${p.name}\` prop is deprecated${typeof p.deprecated === "string" ? ` since ${p.deprecated}` : ""}`
+      })));
+    }
+  }
+  return result;
+}
+function hasNearbyMatch(lines, i, lookahead, pattern) {
+  const end = Math.min(i + lookahead, lines.length);
+  for (let j = i; j < end; j++) {
+    if (pattern.test(lines[j])) return true;
+  }
+  return false;
+}
+function lintFile(filePath, deprecatedMap, only) {
+  const issues = [];
+  let content;
+  try {
+    content = readFileSync6(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const lines = content.split("\n");
+  const importedComponents = parseAntdImports(content);
+  if (importedComponents.length === 0) return [];
+  const deprecatedChecks = [];
+  if (!only || only === "deprecated") {
+    for (const compName of importedComponents) {
+      const deprecations = deprecatedMap.get(compName);
+      if (!deprecations) continue;
+      for (const dep of deprecations) {
+        deprecatedChecks.push({ compName, dep, regex: new RegExp(`\\b${escapeRegExp(dep.prop)}\\b\\s*[=({]`) });
+      }
+    }
+  }
+  const hasImage = importedComponents.includes("Image");
+  const hasTable = importedComponents.includes("Table");
+  const hasSelect = importedComponents.includes("Select") || importedComponents.includes("TreeSelect");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const { compName, dep, regex } of deprecatedChecks) {
+      if (regex.test(line)) {
+        issues.push({
+          file: filePath,
+          line: i + 1,
+          rule: "deprecated",
+          severity: "warning",
+          message: `${compName} ${dep.message}`
+        });
+      }
+    }
+    if (!only || only === "best-practice") {
+      if (/style\s*=\s*\{\{/.test(line) && importedComponents.some((c) => line.includes(`<${c}`))) {
+        issues.push({
+          file: filePath,
+          line: i + 1,
+          rule: "best-practice",
+          severity: "warning",
+          message: "Consider using `classNames` / `styles` props or Design Tokens instead of inline styles"
+        });
+      }
+    }
+    if (!only || only === "a11y") {
+      if (hasImage && /<Image\b/.test(line) && !hasNearbyMatch(lines, i, 5, /alt\s*=/)) {
+        issues.push({
+          file: filePath,
+          line: i + 1,
+          rule: "a11y",
+          severity: "warning",
+          message: "Image component is missing `alt` prop for accessibility"
+        });
+      }
+      if (/<\w+Icon\b/.test(line) && /onClick\s*=/.test(line) && !hasNearbyMatch(lines, i, 3, /aria-label\s*=/)) {
+        issues.push({
+          file: filePath,
+          line: i + 1,
+          rule: "a11y",
+          severity: "warning",
+          message: "Clickable icon should have `aria-label` for screen readers"
+        });
+      }
+      if (/Form\.Item\b/.test(line) && !hasNearbyMatch(lines, i, 5, /(?:label|aria-label|noStyle)\s*[=]/)) {
+        issues.push({
+          file: filePath,
+          line: i + 1,
+          rule: "a11y",
+          severity: "warning",
+          message: "Form.Item should have a `label` prop for accessibility"
+        });
+      }
+    }
+    if (!only || only === "performance") {
+      if (hasTable && /<Table\b/.test(line) && !hasNearbyMatch(lines, i, 10, /rowKey\s*=/)) {
+        issues.push({
+          file: filePath,
+          line: i + 1,
+          rule: "performance",
+          severity: "warning",
+          message: "Table should have explicit `rowKey` prop for optimal rendering performance"
+        });
+      }
+      if (hasSelect && /<(?:Select|TreeSelect)\b/.test(line) && hasNearbyMatch(lines, i, 10, /virtual\s*=\s*\{?\s*false/)) {
+        issues.push({
+          file: filePath,
+          line: i + 1,
+          rule: "performance",
+          severity: "warning",
+          message: "Disabling `virtual` scroll on Select may cause performance issues with large datasets"
+        });
+      }
+      if (/import\s+antd\b/.test(line) || /import\s+\*\s+as\s+\w+\s+from\s+['"]antd['"]/.test(line)) {
+        issues.push({
+          file: filePath,
+          line: i + 1,
+          rule: "performance",
+          severity: "error",
+          message: "Avoid wildcard import from antd. Use named imports: `import { Button } from 'antd'`"
+        });
+      }
+    }
+  }
+  return issues;
+}
+function registerLintCommand(program2) {
+  program2.command("lint [target]").description("Check antd usage against best practices").option("--only <category>", "Only check specific category (deprecated, a11y, performance, best-practice)").action((target, cmdOpts) => {
+    const opts = program2.opts();
+    const targetPath = target || ".";
+    const versionInfo = detectVersion(opts.version);
+    const store = loadMetadata(versionInfo.majorVersion);
+    const deprecatedMap = getDeprecatedProps(store);
+    const files = collectFiles(targetPath);
+    const allIssues = [];
+    for (const file of files) {
+      allIssues.push(...lintFile(file, deprecatedMap, cmdOpts.only));
+    }
+    const summary = {
+      total: allIssues.length,
+      deprecated: allIssues.filter((i) => i.rule === "deprecated").length,
+      a11y: allIssues.filter((i) => i.rule === "a11y").length,
+      performance: allIssues.filter((i) => i.rule === "performance").length,
+      "best-practice": allIssues.filter((i) => i.rule === "best-practice").length
+    };
+    if (opts.format === "json") {
+      output({ issues: allIssues, summary }, "json");
+      return;
+    }
+    if (allIssues.length === 0) {
+      console.log(`Scanned ${files.length} files. No issues found.`);
+      return;
+    }
+    console.log(`Scanned ${files.length} files. Found ${allIssues.length} issues:
+`);
+    for (const issue of allIssues) {
+      const icon = issue.severity === "error" ? "\u2717" : "\u26A0";
+      console.log(`  ${icon} ${issue.file}:${issue.line} [${issue.rule}]`);
+      console.log(`    ${issue.message}`);
+    }
+    console.log(`
+Summary: ${summary.deprecated} deprecated, ${summary.a11y} a11y, ${summary.performance} performance, ${summary["best-practice"]} best-practice`);
+  });
+}
+
+// src/commands/migrate-v4-to-v5.ts
+var V4_TO_V5_STEPS = [
+  // Global changes
+  {
+    component: "Global",
+    breaking: true,
+    description: "Design token system replaces Less variables. All Less variable overrides must be migrated to CSS-in-JS tokens via ConfigProvider.",
+    autoFixable: false,
+    guide: "https://ant.design/docs/react/migrate-less-variables",
+    migrationGuide: `1. Remove all Less variable overrides (modifyVars, less-loader theme config)
+2. Wrap your app with ConfigProvider and pass a theme object
+3. Map Less variables to Design Tokens (e.g. @primary-color \u2192 token.colorPrimary)
+4. Remove babel-plugin-import if present (v5 supports tree-shaking natively)`,
+    before: `// webpack.config.js or .umirc.ts
+theme: { '@primary-color': '#1890ff' }
+
+// or .less file
+@import '~antd/dist/antd.less';
+@primary-color: #1890ff;`,
+    after: `import { ConfigProvider } from 'antd';
+<ConfigProvider theme={{ token: { colorPrimary: '#1890ff' } }}>
+  <App />
+</ConfigProvider>`
+  },
+  {
+    component: "Global",
+    breaking: true,
+    description: "Component styles no longer include CSS reset. Wrap app with <App /> component to restore.",
+    autoFixable: false,
+    guide: "https://ant.design/components/app",
+    searchPattern: `import\\s*\\{[^}]*\\}\\s*from\\s*['"]antd['"]`,
+    migrationGuide: `1. Import App component from antd
+2. Wrap your root component with <App />
+3. Use App.useApp() hook to access message, notification, modal instances`,
+    before: `import { Button } from 'antd';
+
+const MyApp = () => <Button>Click</Button>;`,
+    after: `import { App, Button } from 'antd';
+
+const MyApp = () => (
+  <App>
+    <Button>Click</Button>
+  </App>
+);`
+  },
+  {
+    component: "Global",
+    breaking: true,
+    description: "Moment.js replaced by Day.js. All date-related components (DatePicker, TimePicker, Calendar) now use Day.js.",
+    autoFixable: true,
+    codemod: "v5-removed-component-migration",
+    searchPattern: `import\\s+moment\\s+from\\s+['"]moment['"]`,
+    migrationGuide: `1. Replace moment imports with dayjs
+2. dayjs API is mostly compatible with moment
+3. If you need locale support, import dayjs locale separately
+4. If you need plugins (isBetween, etc.), import and extend dayjs`,
+    before: `import moment from 'moment';
+<DatePicker value={moment('2024-01-01')} />`,
+    after: `import dayjs from 'dayjs';
+<DatePicker value={dayjs('2024-01-01')} />`
+  },
+  {
+    component: "Global",
+    breaking: true,
+    description: "babel-plugin-import is no longer needed. antd v5 supports tree-shaking natively.",
+    autoFixable: false,
+    searchPattern: `babel-plugin-import`,
+    migrationGuide: `1. Remove babel-plugin-import from babel config
+2. Remove related configuration in .babelrc, babel.config.js, or package.json
+3. Direct imports like \`import { Button } from 'antd'\` work without the plugin`
+  },
+  {
+    component: "Global",
+    breaking: true,
+    description: "`antd/dist/antd.css` and `antd/dist/antd.less` removed. CSS-in-JS generates styles automatically.",
+    autoFixable: true,
+    codemod: "v5-removed-component-migration",
+    searchPattern: `import\\s+['"]antd/dist/antd\\.(css|less)['"]`,
+    migrationGuide: `Remove the global CSS/Less import. Styles are now injected via CSS-in-JS automatically.`,
+    before: `import 'antd/dist/antd.css';
+// or
+import 'antd/dist/antd.less';`,
+    after: `// No global import needed \u2014 styles are auto-injected`
+  },
+  // Prop renames (visible → open)
+  {
+    component: "Modal",
+    breaking: true,
+    description: "Prop `visible` renamed to `open`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<Modal[^>]*\\bvisible\\b`,
+    before: `<Modal visible={show} onCancel={onClose}>`,
+    after: `<Modal open={show} onCancel={onClose}>`,
+    migrationGuide: `Search for \`<Modal\` with \`visible\` prop and rename to \`open\`. Also applies to Modal.confirm, Modal.info, etc.`
+  },
+  {
+    component: "Drawer",
+    breaking: true,
+    description: "Prop `visible` renamed to `open`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<Drawer[^>]*\\bvisible\\b`,
+    before: `<Drawer visible={show} onClose={onClose}>`,
+    after: `<Drawer open={show} onClose={onClose}>`
+  },
+  {
+    component: "Tooltip",
+    breaking: true,
+    description: "Prop `visible` renamed to `open`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<Tooltip[^>]*\\bvisible\\b`,
+    before: `<Tooltip visible={show}>`,
+    after: `<Tooltip open={show}>`
+  },
+  {
+    component: "Popover",
+    breaking: true,
+    description: "Prop `visible` renamed to `open`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<Popover[^>]*\\bvisible\\b`,
+    before: `<Popover visible={show}>`,
+    after: `<Popover open={show}>`
+  },
+  {
+    component: "Popconfirm",
+    breaking: true,
+    description: "Prop `visible` renamed to `open`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<Popconfirm[^>]*\\bvisible\\b`,
+    before: `<Popconfirm visible={show}>`,
+    after: `<Popconfirm open={show}>`
+  },
+  {
+    component: "Dropdown",
+    breaking: true,
+    description: "Prop `visible` renamed to `open`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<Dropdown[^>]*\\bvisible\\b`,
+    before: `<Dropdown visible={show}>`,
+    after: `<Dropdown open={show}>`
+  },
+  {
+    component: "Tag",
+    breaking: true,
+    description: "Prop `visible` removed. Use conditional rendering instead.",
+    autoFixable: false,
+    searchPattern: `<Tag[^>]*\\bvisible\\b`,
+    before: `<Tag visible={show}>Tag</Tag>`,
+    after: `{show && <Tag>Tag</Tag>}`,
+    migrationGuide: `Replace \`visible\` prop with conditional rendering using \`{condition && <Tag>...</Tag>}\`.`
+  },
+  // dropdownClassName → popupClassName
+  {
+    component: "Select",
+    breaking: true,
+    description: "Prop `dropdownClassName` renamed to `popupClassName`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<Select[^>]*\\bdropdownClassName\\b`,
+    before: `<Select dropdownClassName="my-dropdown" />`,
+    after: `<Select popupClassName="my-dropdown" />`
+  },
+  {
+    component: "Select",
+    breaking: true,
+    description: "Prop `dropdownMatchSelectWidth` renamed to `popupMatchSelectWidth`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<Select[^>]*\\bdropdownMatchSelectWidth\\b`,
+    before: `<Select dropdownMatchSelectWidth={false} />`,
+    after: `<Select popupMatchSelectWidth={false} />`
+  },
+  {
+    component: "TreeSelect",
+    breaking: true,
+    description: "Prop `dropdownClassName` renamed to `popupClassName`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<TreeSelect[^>]*\\bdropdownClassName\\b`,
+    before: `<TreeSelect dropdownClassName="my-dropdown" />`,
+    after: `<TreeSelect popupClassName="my-dropdown" />`
+  },
+  {
+    component: "Cascader",
+    breaking: true,
+    description: "Prop `dropdownClassName` renamed to `popupClassName`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<Cascader[^>]*\\bdropdownClassName\\b`,
+    before: `<Cascader dropdownClassName="my-dropdown" />`,
+    after: `<Cascader popupClassName="my-dropdown" />`
+  },
+  {
+    component: "AutoComplete",
+    breaking: true,
+    description: "Prop `dropdownClassName` renamed to `popupClassName`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<AutoComplete[^>]*\\bdropdownClassName\\b`,
+    before: `<AutoComplete dropdownClassName="my-dropdown" />`,
+    after: `<AutoComplete popupClassName="my-dropdown" />`
+  },
+  {
+    component: "DatePicker",
+    breaking: true,
+    description: "Prop `dropdownClassName` renamed to `popupClassName`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<DatePicker[^>]*\\bdropdownClassName\\b`,
+    before: `<DatePicker dropdownClassName="my-popup" />`,
+    after: `<DatePicker popupClassName="my-popup" />`
+  },
+  {
+    component: "TimePicker",
+    breaking: true,
+    description: "Prop `dropdownClassName` renamed to `popupClassName`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<TimePicker[^>]*\\bdropdownClassName\\b`,
+    before: `<TimePicker dropdownClassName="my-popup" />`,
+    after: `<TimePicker popupClassName="my-popup" />`
+  },
+  {
+    component: "Mentions",
+    breaking: true,
+    description: "Prop `dropdownClassName` renamed to `popupClassName`",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `<Mentions[^>]*\\bdropdownClassName\\b`,
+    before: `<Mentions dropdownClassName="my-dropdown" />`,
+    after: `<Mentions popupClassName="my-dropdown" />`
+  },
+  // Removed components
+  {
+    component: "Comment",
+    breaking: true,
+    description: "Removed from antd. Use @ant-design/compatible instead.",
+    autoFixable: false,
+    guide: "https://ant.design/docs/react/migration-v5",
+    searchPattern: `import\\s*\\{[^}]*\\bComment\\b[^}]*\\}\\s*from\\s*['"]antd['"]`,
+    migrationGuide: `1. Install @ant-design/compatible: npm install @ant-design/compatible
+2. Change import from 'antd' to '@ant-design/compatible'`,
+    before: `import { Comment } from 'antd';`,
+    after: `import { Comment } from '@ant-design/compatible';`
+  },
+  {
+    component: "PageHeader",
+    breaking: true,
+    description: "Removed from antd. Use @ant-design/pro-components instead.",
+    autoFixable: false,
+    guide: "https://ant.design/docs/react/migration-v5",
+    searchPattern: `import\\s*\\{[^}]*\\bPageHeader\\b[^}]*\\}\\s*from\\s*['"]antd['"]`,
+    migrationGuide: `1. Install @ant-design/pro-components: npm install @ant-design/pro-components
+2. Change import from 'antd' to '@ant-design/pro-components'`,
+    before: `import { PageHeader } from 'antd';`,
+    after: `import { PageHeader } from '@ant-design/pro-components';`
+  },
+  {
+    component: "BackTop",
+    breaking: true,
+    description: "Removed. Use FloatButton.BackTop instead.",
+    autoFixable: true,
+    codemod: "v5-removed-component-migration",
+    searchPattern: `import\\s*\\{[^}]*\\bBackTop\\b[^}]*\\}\\s*from\\s*['"]antd['"]`,
+    before: `import { BackTop } from 'antd';
+<BackTop />`,
+    after: `import { FloatButton } from 'antd';
+<FloatButton.BackTop />`
+  },
+  // API changes
+  {
+    component: "message",
+    breaking: true,
+    description: "Static methods `message.xxx()` deprecated. Use `App.useApp()` hook instead for context support.",
+    autoFixable: false,
+    searchPattern: `\\bmessage\\.(success|error|warning|info|loading|open)\\(`,
+    migrationGuide: `1. Wrap app with <App /> component
+2. Use const { message } = App.useApp(); in functional components
+3. Replace static message.xxx() calls with the hook-provided instance`,
+    before: `import { message } from 'antd';
+message.success('Done!');`,
+    after: `import { App } from 'antd';
+const MyComponent = () => {
+  const { message } = App.useApp();
+  message.success('Done!');
+};`
+  },
+  {
+    component: "notification",
+    breaking: true,
+    description: "Static methods `notification.xxx()` deprecated. Use `App.useApp()` hook instead.",
+    autoFixable: false,
+    searchPattern: `\\bnotification\\.(success|error|warning|info|open)\\(`,
+    migrationGuide: `Same pattern as message \u2014 use App.useApp() to get notification instance.`,
+    before: `import { notification } from 'antd';
+notification.success({ message: 'Done!' });`,
+    after: `import { App } from 'antd';
+const MyComponent = () => {
+  const { notification } = App.useApp();
+  notification.success({ message: 'Done!' });
+};`
+  },
+  {
+    component: "Modal",
+    breaking: true,
+    description: "Static methods `Modal.confirm()` etc. deprecated. Use `App.useApp()` hook instead.",
+    autoFixable: false,
+    searchPattern: `\\bModal\\.(confirm|info|success|error|warning)\\(`,
+    migrationGuide: `Same pattern as message/notification \u2014 use App.useApp() to get modal instance.`,
+    before: `import { Modal } from 'antd';
+Modal.confirm({ title: 'Sure?' });`,
+    after: `import { App } from 'antd';
+const MyComponent = () => {
+  const { modal } = App.useApp();
+  modal.confirm({ title: 'Sure?' });
+};`
+  },
+  // Table
+  {
+    component: "Table",
+    breaking: true,
+    description: "Column `filterDropdown` render args changed. `confirm({ closeDropdown: false })` replaced by separate `close` function.",
+    autoFixable: false,
+    searchPattern: `filterDropdown.*closeDropdown`,
+    migrationGuide: `Update filterDropdown render function signature to use the new \`close\` parameter instead of \`confirm({ closeDropdown: false })\`.`,
+    before: `filterDropdown: ({ confirm }) => (
+  <Button onClick={() => confirm({ closeDropdown: false })}>Filter</Button>
+)`,
+    after: `filterDropdown: ({ confirm, close }) => (
+  <Button onClick={() => close()}>Filter</Button>
+)`
+  },
+  // Form
+  {
+    component: "Form",
+    breaking: false,
+    description: "Prop `labelCol` and `wrapperCol` can now be set globally via ConfigProvider.",
+    autoFixable: false,
+    migrationGuide: `Optional improvement: move repeated labelCol/wrapperCol config to ConfigProvider for consistency.`
+  },
+  // Slider
+  {
+    component: "Slider",
+    breaking: true,
+    description: "Tooltip-related APIs converged into `tooltip` property. `tooltipVisible` \u2192 `tooltip.open`, `tipFormatter` \u2192 `tooltip.formatter`, etc.",
+    autoFixable: false,
+    searchPattern: `<Slider[^>]*\\b(tooltipVisible|tipFormatter|tooltipPlacement|getTooltipPopupContainer)\\b`,
+    before: `<Slider tooltipVisible={show} tipFormatter={(v) => \`\${v}%\`} />`,
+    after: `<Slider tooltip={{ open: show, formatter: (v) => \`\${v}%\` }} />`,
+    migrationGuide: `Migrate Slider tooltip props:
+- tooltipVisible \u2192 tooltip.open
+- tipFormatter \u2192 tooltip.formatter
+- tooltipPlacement \u2192 tooltip.placement
+- getTooltipPopupContainer \u2192 tooltip.getPopupContainer`
+  },
+  // Table filterDropdownVisible
+  {
+    component: "Table",
+    breaking: true,
+    description: "Column prop `filterDropdownVisible` renamed to `filterDropdownOpen`.",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `filterDropdownVisible`,
+    before: `{ title: 'Name', dataIndex: 'name', filterDropdownVisible: visible }`,
+    after: `{ title: 'Name', dataIndex: 'name', filterDropdownOpen: visible }`,
+    migrationGuide: `Search for \`filterDropdownVisible\` in Table column definitions and rename to \`filterDropdownOpen\`.`
+  },
+  // Drawer style/className migration
+  {
+    component: "Drawer",
+    breaking: true,
+    description: "Drawer `style` and `className` now apply to the panel node. Use `rootStyle` and `rootClassName` for the wrapper.",
+    autoFixable: false,
+    searchPattern: `<Drawer[^>]*\\b(style|className)\\s*=`,
+    migrationGuide: `In v5, Drawer \`style\` and \`className\` are migrated to the Drawer panel node.
+If you were using them to style the wrapper/mask, replace with \`rootStyle\` and \`rootClassName\`.`,
+    before: `<Drawer className="my-drawer" style={{ zIndex: 1000 }}>`,
+    after: `<Drawer rootClassName="my-drawer" rootStyle={{ zIndex: 1000 }}>`
+  },
+  // Notification close → destroy
+  {
+    component: "notification",
+    breaking: true,
+    description: "Static method `notification.close()` renamed to `notification.destroy()`. Static config options restricted.",
+    autoFixable: false,
+    searchPattern: `\\bnotification\\.close\\(`,
+    before: `notification.close(key);`,
+    after: `notification.destroy(key);`,
+    migrationGuide: `1. Rename notification.close() to notification.destroy()
+2. Static methods no longer allow dynamic prefixCls, maxCount, top, bottom, getContainer in open()
+3. Use useNotification hook if you need different configurations`
+  },
+  // message.warn removed
+  {
+    component: "message",
+    breaking: true,
+    description: "`message.warn()` completely removed. Use `message.warning()` instead.",
+    autoFixable: true,
+    codemod: "v5-props-changed-migration",
+    searchPattern: `\\bmessage\\.warn\\(`,
+    before: `message.warn('Something went wrong');`,
+    after: `message.warning('Something went wrong');`,
+    migrationGuide: `Search for \`message.warn(\` and replace with \`message.warning(\`.`
+  },
+  // IE not supported
+  {
+    component: "Global",
+    breaking: true,
+    description: "IE browser is no longer supported. v5 uses CSS-in-JS and modern CSS features.",
+    autoFixable: false,
+    migrationGuide: `If your project needs IE support, you cannot upgrade to v5. Consider using @ant-design/cssinjs StyleProvider for :where selector compatibility with older browsers.`
+  }
+];
+
+// src/commands/migrate-v5-to-v6.ts
+var V5_TO_V6_STEPS = [
+  // ─── Global / Environment ───────────────────────────────────────────────────
+  {
+    component: "Global",
+    breaking: true,
+    description: "React >= 18 required. React 17 and earlier are no longer supported.",
+    autoFixable: false,
+    migrationGuide: `1. Upgrade React to 18 or above
+2. Remove @ant-design/v5-patch-for-react-19 if present (no longer needed)`,
+    searchPattern: `@ant-design/v5-patch-for-react-19`,
+    before: `import '@ant-design/v5-patch-for-react-19';`,
+    after: `// Remove this import \u2014 no longer needed in v6`
+  },
+  {
+    component: "Global",
+    breaking: true,
+    description: "@ant-design/icons must be upgraded to v6. Icons v6 is not compatible with antd v5.",
+    autoFixable: false,
+    migrationGuide: `1. Run: npm install @ant-design/icons@6
+2. @ant-design/icons@6 is NOT compatible with antd@5 \u2014 upgrade both together
+3. If build errors occur, verify icon package version matches antd version`
+  },
+  {
+    component: "Global",
+    breaking: true,
+    description: "CSS variables enabled by default. Only modern browsers supported, IE is not supported.",
+    autoFixable: false,
+    migrationGuide: `Verify your target browsers support CSS variables. IE and some older domestic browsers may have issues.`
+  },
+  {
+    component: "Global",
+    breaking: false,
+    description: "DOM structure of many components optimized. Custom styles targeting internal DOM nodes may need adjustment.",
+    autoFixable: false,
+    migrationGuide: `If your project has CSS that targets component internal DOM nodes (specific selectors or hierarchy), inspect and adjust after upgrading.`
+  },
+  // ─── Button ─────────────────────────────────────────────────────────────────
+  {
+    component: "Button",
+    breaking: true,
+    description: 'Prop `type` split into `color` and `variant` for styling. `type="primary"` \u2192 `color="primary" variant="solid"`.',
+    autoFixable: true,
+    codemod: "v6-type-to-variant",
+    searchPattern: `<Button[^>]*\\btype\\s*=\\s*['"](?:primary|dashed|link|text)['"]`,
+    migrationGuide: `Button type prop is decomposed:
+- type="primary" \u2192 color="primary" variant="solid" (or just keep type="primary" as alias)
+- type="dashed" \u2192 variant="dashed"
+- type="link" \u2192 variant="link"
+- type="text" \u2192 variant="text"
+- type="default" \u2192 no change needed`,
+    before: `<Button type="primary">Submit</Button>
+<Button type="dashed">Dashed</Button>
+<Button type="link">Link</Button>
+<Button type="text">Text</Button>`,
+    after: `<Button color="primary" variant="solid">Submit</Button>
+<Button variant="dashed">Dashed</Button>
+<Button variant="link">Link</Button>
+<Button variant="text">Text</Button>`
+  },
+  {
+    component: "Button",
+    breaking: true,
+    description: 'Prop `danger` removed. Use `color="danger"` instead.',
+    autoFixable: true,
+    codemod: "v6-danger-migration",
+    searchPattern: `<Button[^>]*\\bdanger\\b`,
+    before: `<Button danger>Delete</Button>
+<Button type="primary" danger>Delete</Button>`,
+    after: `<Button color="danger">Delete</Button>
+<Button color="danger" variant="solid">Delete</Button>`,
+    migrationGuide: `Search for all Button components with \`danger\` prop. Replace with \`color="danger"\`. If the button also had \`type="primary"\`, add \`variant="solid"\`.`
+  },
+  {
+    component: "Button",
+    breaking: true,
+    description: 'Prop `ghost` removed. Use `variant="outlined"` instead.',
+    autoFixable: true,
+    codemod: "v6-ghost-migration",
+    searchPattern: `<Button[^>]*\\bghost\\b`,
+    before: `<Button ghost>Ghost</Button>
+<Button type="primary" ghost>Ghost Primary</Button>`,
+    after: `<Button variant="outlined">Ghost</Button>
+<Button color="primary" variant="outlined">Ghost Primary</Button>`,
+    migrationGuide: `Search for all Button components with \`ghost\` prop. Replace with \`variant="outlined"\`. Preserve the color from the original \`type\` prop.`
+  },
+  {
+    component: "Button",
+    breaking: false,
+    description: "`iconPosition` deprecated, use `iconPlacement` instead.",
+    autoFixable: true,
+    codemod: "v6-props-changed-migration",
+    searchPattern: `<Button[^>]*\\biconPosition\\b`,
+    before: `<Button iconPosition="end">Click</Button>`,
+    after: `<Button iconPlacement="end">Click</Button>`
+  },
+  {
+    component: "Button.Group",
+    breaking: false,
+    description: "`Button.Group` deprecated, use `Space.Compact` instead.",
+    autoFixable: false,
+    searchPattern: `Button\\.Group`,
+    before: `<Button.Group><Button>A</Button><Button>B</Button></Button.Group>`,
+    after: `<Space.Compact><Button>A</Button><Button>B</Button></Space.Compact>`
+  },
+  // ─── Alert ──────────────────────────────────────────────────────────────────
+  {
+    component: "Alert",
+    breaking: false,
+    description: "`closeText` deprecated \u2192 `closable.closeIcon`; `message` deprecated \u2192 `title`.",
+    autoFixable: false,
+    searchPattern: `<Alert[^>]*\\b(closeText|message)\\s*=`,
+    migrationGuide: `- closeText="Close" \u2192 closable={{ closeIcon: "Close" }}
+- message="Title" \u2192 title="Title"`
+  },
+  // ─── Anchor ─────────────────────────────────────────────────────────────────
+  {
+    component: "Anchor",
+    breaking: false,
+    description: "`Anchor` children usage deprecated, use `items` prop instead.",
+    autoFixable: false,
+    searchPattern: `<Anchor>\\s*<Anchor\\.Link`,
+    migrationGuide: `Replace Anchor children with items prop array.`
+  },
+  // ─── AutoComplete ───────────────────────────────────────────────────────────
+  {
+    component: "AutoComplete",
+    breaking: false,
+    description: "Multiple deprecated props: `dropdownMatchSelectWidth` \u2192 `popupMatchSelectWidth`, `dropdownClassName` \u2192 `classNames.popup.root`, `dropdownRender` \u2192 `popupRender`, `dataSource` \u2192 `options`.",
+    autoFixable: false,
+    searchPattern: `<AutoComplete[^>]*\\b(dropdownMatchSelectWidth|dropdownClassName|dropdownStyle|dropdownRender|onDropdownVisibleChange|dataSource)\\b`,
+    migrationGuide: `- dropdownMatchSelectWidth \u2192 popupMatchSelectWidth
+- dropdownClassName / popupClassName \u2192 classNames.popup.root
+- dropdownStyle \u2192 styles.popup.root
+- dropdownRender \u2192 popupRender
+- onDropdownVisibleChange \u2192 onOpenChange
+- dataSource \u2192 options`
+  },
+  // ─── Avatar.Group ───────────────────────────────────────────────────────────
+  {
+    component: "Avatar.Group",
+    breaking: false,
+    description: "`maxCount`/`maxStyle`/`maxPopoverPlacement`/`maxPopoverTrigger` deprecated, use `max` prop object.",
+    autoFixable: false,
+    searchPattern: `<Avatar\\.Group[^>]*\\b(maxCount|maxStyle|maxPopoverPlacement|maxPopoverTrigger)\\b`,
+    before: `<Avatar.Group maxCount={3} maxStyle={{ color: 'red' }}>`,
+    after: `<Avatar.Group max={{ count: 3, style: { color: 'red' } }}>`
+  },
+  // ─── Breadcrumb ─────────────────────────────────────────────────────────────
+  {
+    component: "Breadcrumb",
+    breaking: false,
+    description: "`routes` deprecated \u2192 `items`; `Breadcrumb.Item` / `Breadcrumb.Separator` deprecated \u2192 `items`.",
+    autoFixable: false,
+    searchPattern: `(Breadcrumb\\.Item|Breadcrumb\\.Separator|<Breadcrumb[^>]*\\broutes\\b)`,
+    migrationGuide: `Replace Breadcrumb children or routes prop with items array.`
+  },
+  // ─── Calendar ───────────────────────────────────────────────────────────────
+  {
+    component: "Calendar",
+    breaking: false,
+    description: "`dateFullCellRender`/`dateCellRender`/`monthFullCellRender`/`monthCellRender` deprecated \u2192 `fullCellRender`/`cellRender`.",
+    autoFixable: false,
+    searchPattern: `<Calendar[^>]*\\b(dateFullCellRender|dateCellRender|monthFullCellRender|monthCellRender)\\b`
+  },
+  // ─── Card ───────────────────────────────────────────────────────────────────
+  {
+    component: "Card",
+    breaking: false,
+    description: "`headStyle` \u2192 `styles.header`; `bodyStyle` \u2192 `styles.body`; `bordered` \u2192 `variant`.",
+    autoFixable: false,
+    searchPattern: `<Card[^>]*\\b(headStyle|bodyStyle|bordered)\\b`,
+    migrationGuide: `- headStyle \u2192 styles.header
+- bodyStyle \u2192 styles.body
+- bordered={false} \u2192 variant="borderless"`
+  },
+  // ─── Cascader ───────────────────────────────────────────────────────────────
+  {
+    component: "Cascader",
+    breaking: false,
+    description: "Multiple deprecated props: `dropdownClassName` \u2192 `classNames.popup.root`, `bordered` \u2192 `variant`, `onPopupVisibleChange` \u2192 `onOpenChange`.",
+    autoFixable: false,
+    searchPattern: `<Cascader[^>]*\\b(dropdownClassName|dropdownStyle|dropdownRender|dropdownMenuColumnStyle|onDropdownVisibleChange|onPopupVisibleChange|bordered)\\b`
+  },
+  // ─── Collapse ───────────────────────────────────────────────────────────────
+  {
+    component: "Collapse",
+    breaking: false,
+    description: "`destroyInactivePanel` \u2192 `destroyOnHidden`; `expandIconPosition` \u2192 `expandIconPlacement`.",
+    autoFixable: false,
+    searchPattern: `<Collapse[^>]*\\b(destroyInactivePanel|expandIconPosition)\\b`
+  },
+  // ─── DatePicker ─────────────────────────────────────────────────────────────
+  {
+    component: "DatePicker",
+    breaking: false,
+    description: "Multiple deprecated props: `popupClassName` \u2192 `classNames.popup.root`, `bordered` \u2192 `variant`, `onSelect` \u2192 `onCalendarChange`.",
+    autoFixable: false,
+    searchPattern: `<(DatePicker|RangePicker)[^>]*\\b(dropdownClassName|popupClassName|popupStyle|bordered|onSelect)\\b`
+  },
+  // ─── Descriptions ──────────────────────────────────────────────────────────
+  {
+    component: "Descriptions",
+    breaking: false,
+    description: "`labelStyle` \u2192 `styles.label`; `contentStyle` \u2192 `styles.content`.",
+    autoFixable: false,
+    searchPattern: `<Descriptions[^>]*\\b(labelStyle|contentStyle)\\b`
+  },
+  // ─── Divider ────────────────────────────────────────────────────────────────
+  {
+    component: "Divider",
+    breaking: false,
+    description: "`type` deprecated \u2192 `orientation`; `orientationMargin` \u2192 `styles.content.margin`.",
+    autoFixable: false,
+    searchPattern: `<Divider[^>]*\\b(type\\s*=|orientationMargin)\\b`
+  },
+  // ─── Drawer ─────────────────────────────────────────────────────────────────
+  {
+    component: "Drawer",
+    breaking: false,
+    description: "Style props deprecated: `headerStyle`/`bodyStyle`/`footerStyle`/`maskStyle`/`drawerStyle`/`contentWrapperStyle` \u2192 `styles.*`; `width`/`height` \u2192 `size`; `destroyInactivePanel` \u2192 `destroyOnHidden`.",
+    autoFixable: false,
+    searchPattern: `<Drawer[^>]*\\b(headerStyle|bodyStyle|footerStyle|contentWrapperStyle|maskStyle|drawerStyle|destroyInactivePanel)\\b`,
+    migrationGuide: `- headerStyle \u2192 styles.header
+- bodyStyle \u2192 styles.body
+- footerStyle \u2192 styles.footer
+- contentWrapperStyle \u2192 styles.wrapper
+- maskStyle \u2192 styles.mask
+- drawerStyle \u2192 styles.section
+- width/height \u2192 size
+- destroyInactivePanel \u2192 destroyOnHidden`
+  },
+  // ─── Dropdown ───────────────────────────────────────────────────────────────
+  {
+    component: "Dropdown",
+    breaking: false,
+    description: "`overlayClassName` \u2192 `classNames.root`; `overlayStyle` \u2192 `styles.root`; `destroyPopupOnHide` \u2192 `destroyOnHidden`. `Dropdown.Button` deprecated \u2192 `Space.Compact + Dropdown + Button`.",
+    autoFixable: false,
+    searchPattern: `(Dropdown\\.Button|<Dropdown[^>]*\\b(overlayClassName|overlayStyle|destroyPopupOnHide|dropdownRender)\\b)`
+  },
+  // ─── Form ───────────────────────────────────────────────────────────────────
+  {
+    component: "Form",
+    breaking: true,
+    description: "`onFinish` no longer includes all Form.List data. Unregistered Form.Item fields are excluded.",
+    autoFixable: false,
+    migrationGuide: `In v5, Form.List was treated as a single Field, causing onFinish to include all data.
+In v6, only registered Form.Item fields are included.
+You no longer need getFieldsValue({ strict: true }) to filter.`,
+    before: `const onFinish = (values) => {
+  const realValues = getFieldsValue({ strict: true });
+};`,
+    after: `const onFinish = (values) => {
+  const realValues = values; // Already filtered in v6
+};`
+  },
+  // ─── Image ──────────────────────────────────────────────────────────────────
+  {
+    component: "Image",
+    breaking: false,
+    description: "`visible` \u2192 `open`; `onVisibleChange` \u2192 `onOpenChange`; `wrapperStyle` \u2192 `styles.root`; `maskClassName` \u2192 `classNames.cover`; `toolbarRender` \u2192 `actionsRender`.",
+    autoFixable: false,
+    searchPattern: `<Image[^>]*\\b(visible|onVisibleChange|wrapperStyle|maskClassName|rootClassName|toolbarRender)\\b`
+  },
+  // ─── Input.Group ────────────────────────────────────────────────────────────
+  {
+    component: "Input.Group",
+    breaking: false,
+    description: "`Input.Group` deprecated, use `Space.Compact` instead.",
+    autoFixable: false,
+    searchPattern: `Input\\.Group`,
+    before: `<Input.Group compact><Input /><Input /></Input.Group>`,
+    after: `<Space.Compact><Input /><Input /></Space.Compact>`
+  },
+  // ─── Menu ───────────────────────────────────────────────────────────────────
+  {
+    component: "Menu",
+    breaking: false,
+    description: "`children` deprecated, use `items` prop instead.",
+    autoFixable: false,
+    searchPattern: `<Menu>\\s*<Menu\\.Item`
+  },
+  // ─── Modal ──────────────────────────────────────────────────────────────────
+  {
+    component: "Modal",
+    breaking: false,
+    description: "`bodyStyle` \u2192 `styles.body`; `maskStyle` \u2192 `styles.mask`; `destroyOnClose` \u2192 `destroyOnHidden`.",
+    autoFixable: false,
+    searchPattern: `<Modal[^>]*\\b(bodyStyle|maskStyle|destroyOnClose)\\b`
+  },
+  // ─── Notification ──────────────────────────────────────────────────────────
+  {
+    component: "notification",
+    breaking: false,
+    description: "`btn` deprecated \u2192 `actions`; `message` deprecated \u2192 `title`.",
+    autoFixable: false,
+    searchPattern: `notification\\.(open|success|error|info|warning)\\(\\{[^}]*(\\bbtn\\b|\\bmessage\\b)`
+  },
+  // ─── Progress ───────────────────────────────────────────────────────────────
+  {
+    component: "Progress",
+    breaking: false,
+    description: "`strokeWidth`/`width` \u2192 `size`; `trailColor` \u2192 `railColor`; `gapPosition` \u2192 `gapPlacement`.",
+    autoFixable: false,
+    searchPattern: `<Progress[^>]*\\b(strokeWidth|trailColor|gapPosition)\\b`
+  },
+  // ─── Select ─────────────────────────────────────────────────────────────────
+  {
+    component: "Select",
+    breaking: false,
+    description: "Multiple deprecated props: `dropdownClassName` \u2192 `classNames.popup.root`, `dropdownRender` \u2192 `popupRender`, `bordered` \u2192 `variant`, `onDropdownVisibleChange` \u2192 `onOpenChange`.",
+    autoFixable: false,
+    searchPattern: `<Select[^>]*\\b(dropdownClassName|dropdownStyle|dropdownRender|onDropdownVisibleChange|bordered)\\b`
+  },
+  // ─── Slider ─────────────────────────────────────────────────────────────────
+  {
+    component: "Slider",
+    breaking: false,
+    description: "Tooltip props deprecated: `tooltipPrefixCls` \u2192 `tooltip.prefixCls`, `tipFormatter` \u2192 `tooltip.formatter`, `tooltipVisible` \u2192 `tooltip.open`, `tooltipPlacement` \u2192 `tooltip.placement`.",
+    autoFixable: false,
+    searchPattern: `<Slider[^>]*\\b(tooltipPrefixCls|tipFormatter|tooltipVisible|tooltipPlacement|getTooltipPopupContainer)\\b`
+  },
+  // ─── Space ──────────────────────────────────────────────────────────────────
+  {
+    component: "Space",
+    breaking: false,
+    description: "`direction` \u2192 `orientation`; `split` \u2192 `separator`.",
+    autoFixable: false,
+    searchPattern: `<Space[^>]*\\b(direction|split)\\s*=`
+  },
+  // ─── Steps ──────────────────────────────────────────────────────────────────
+  {
+    component: "Steps",
+    breaking: false,
+    description: '`labelPlacement` \u2192 `titlePlacement`; `progressDot` \u2192 `type="dot"`; `direction` \u2192 `orientation`; `items.description` \u2192 `items.content`.',
+    autoFixable: false,
+    searchPattern: `<Steps[^>]*\\b(labelPlacement|progressDot|direction)\\b`
+  },
+  // ─── Table ──────────────────────────────────────────────────────────────────
+  {
+    component: "Table",
+    breaking: false,
+    description: "`pagination.position` \u2192 `pagination.placement`; `filterDropdownOpen` \u2192 `filterDropdownProps.open`; `onFilterDropdownOpenChange` \u2192 `filterDropdownProps.onOpenChange`.",
+    autoFixable: false,
+    searchPattern: `(filterDropdownOpen|onFilterDropdownOpenChange|filterCheckall)`
+  },
+  // ─── Tabs ───────────────────────────────────────────────────────────────────
+  {
+    component: "Tabs",
+    breaking: false,
+    description: "`tabPosition` \u2192 `tabPlacement`; `destroyInactiveTabPane` \u2192 `destroyOnHidden`; `Tabs.TabPane` deprecated \u2192 `items`.",
+    autoFixable: false,
+    searchPattern: `(Tabs\\.TabPane|<Tabs[^>]*\\b(tabPosition|destroyInactiveTabPane)\\b)`
+  },
+  // ─── Tag ────────────────────────────────────────────────────────────────────
+  {
+    component: "Tag",
+    breaking: true,
+    description: 'Default trailing margin removed. `bordered={false}` \u2192 `variant="filled"`; `color="xxx-inverse"` \u2192 `variant="solid"`.',
+    autoFixable: false,
+    searchPattern: `<Tag[^>]*\\b(bordered|color\\s*=\\s*['"][^'"]*-inverse)`,
+    migrationGuide: `- Tag trailing margin removed. Add margin via ConfigProvider tag.styles if needed.
+- bordered={false} \u2192 variant="filled"
+- color="xxx-inverse" \u2192 variant="solid"`
+  },
+  // ─── Timeline ───────────────────────────────────────────────────────────────
+  {
+    component: "Timeline",
+    breaking: false,
+    description: "`Timeline.Item` deprecated \u2192 `items`; `pending`/`pendingDot` deprecated \u2192 `items`; `mode=left|right` \u2192 `mode=start|end`.",
+    autoFixable: false,
+    searchPattern: `(Timeline\\.Item|<Timeline[^>]*\\b(pending|pendingDot|mode\\s*=\\s*['"](?:left|right))\\b)`
+  },
+  // ─── Tooltip ────────────────────────────────────────────────────────────────
+  {
+    component: "Tooltip",
+    breaking: false,
+    description: "`overlayStyle` \u2192 `styles.root`; `overlayInnerStyle` \u2192 `styles.container`; `overlayClassName` \u2192 `classNames.root`; `destroyTooltipOnHide` \u2192 `destroyOnHidden`.",
+    autoFixable: false,
+    searchPattern: `<Tooltip[^>]*\\b(overlayStyle|overlayInnerStyle|overlayClassName|destroyTooltipOnHide)\\b`
+  },
+  // ─── Transfer ───────────────────────────────────────────────────────────────
+  {
+    component: "Transfer",
+    breaking: false,
+    description: "`listStyle` \u2192 `styles.section`; `operationStyle` \u2192 `styles.actions`; `operations` \u2192 `actions`.",
+    autoFixable: false,
+    searchPattern: `<Transfer[^>]*\\b(listStyle|operationStyle|operations)\\b`
+  },
+  // ─── TreeSelect ─────────────────────────────────────────────────────────────
+  {
+    component: "TreeSelect",
+    breaking: false,
+    description: "Multiple deprecated props: `dropdownClassName` \u2192 `classNames.popup.root`, `dropdownRender` \u2192 `popupRender`, `bordered` \u2192 `variant`, `onDropdownVisibleChange` \u2192 `onOpenChange`.",
+    autoFixable: false,
+    searchPattern: `<TreeSelect[^>]*\\b(dropdownClassName|dropdownStyle|dropdownRender|onDropdownVisibleChange|bordered)\\b`
+  },
+  // ─── Overlay: Modal, Drawer mask blur ──────────────────────────────────────
+  {
+    component: "Global",
+    breaking: false,
+    description: "Modal/Drawer mask blur enabled by default. Disable via ConfigProvider if undesired.",
+    autoFixable: false,
+    migrationGuide: `If you don't want the mask blur effect:
+<ConfigProvider modal={{ mask: { blur: false } }} drawer={{ mask: { blur: false } }}>
+  <App />
+</ConfigProvider>`
+  }
+];
+
+// src/commands/migrate.ts
+var MIGRATION_GUIDES = {
+  "4-5": V4_TO_V5_STEPS,
+  "5-6": V5_TO_V6_STEPS
+};
+function formatText(from, to, steps) {
+  const autoFixable = steps.filter((s) => s.autoFixable).length;
+  const manual = steps.length - autoFixable;
+  console.log(`Migration Guide: v${from} \u2192 v${to}
+`);
+  const grouped = groupByComponent(steps);
+  for (const [comp, compSteps] of grouped) {
+    console.log(`  ${comp}:`);
+    for (const step of compSteps) {
+      const icon = step.autoFixable ? "\u{1F527}" : "\u{1F4DD}";
+      const breaking = step.breaking ? " [BREAKING]" : "";
+      console.log(`    ${icon}${breaking} ${step.description}`);
+      if (step.guide) console.log(`       Guide: ${step.guide}`);
+    }
+    console.log("");
+  }
+  console.log(`Total: ${steps.length} steps (${autoFixable} auto-fixable, ${manual} manual)`);
+}
+function formatMarkdown(from, to, steps) {
+  const lines = [];
+  const autoFixable = steps.filter((s) => s.autoFixable).length;
+  const manual = steps.length - autoFixable;
+  lines.push(`# Migration Guide: antd v${from} \u2192 v${to}`);
+  lines.push("");
+  lines.push(`> ${steps.length} total steps: ${autoFixable} auto-fixable, ${manual} manual`);
+  lines.push("");
+  const grouped = groupByComponent(steps);
+  for (const [comp, compSteps] of grouped) {
+    lines.push(`## ${comp}`);
+    lines.push("");
+    for (const step of compSteps) {
+      const badge = step.breaking ? "**BREAKING**" : "non-breaking";
+      const fix = step.autoFixable ? "\u{1F527} auto-fixable" : "\u{1F4DD} manual";
+      lines.push(`### ${step.description}`);
+      lines.push("");
+      lines.push(`${badge} | ${fix}`);
+      lines.push("");
+      if (step.migrationGuide) {
+        lines.push(step.migrationGuide);
+        lines.push("");
+      }
+      if (step.before && step.after) {
+        lines.push("**Before:**");
+        lines.push("```tsx");
+        lines.push(step.before);
+        lines.push("```");
+        lines.push("");
+        lines.push("**After:**");
+        lines.push("```tsx");
+        lines.push(step.after);
+        lines.push("```");
+        lines.push("");
+      }
+      if (step.searchPattern) {
+        lines.push(`**Search pattern:** \`${step.searchPattern}\``);
+        lines.push("");
+      }
+      if (step.guide) {
+        lines.push(`**Reference:** ${step.guide}`);
+        lines.push("");
+      }
+    }
+  }
+  console.log(lines.join("\n"));
+}
+function formatJson(from, to, steps) {
+  const autoFixable = steps.filter((s) => s.autoFixable).length;
+  const manual = steps.length - autoFixable;
+  output({
+    from,
+    to,
+    steps,
+    summary: { total: steps.length, autoFixable, manual }
+  }, "json");
+}
+function formatApplyPrompt(from, to, steps, dir, format) {
+  const fixableSteps = steps.filter((s) => s.autoFixable && s.searchPattern);
+  const manualSteps = steps.filter((s) => !s.autoFixable);
+  if (format === "json") {
+    output({
+      from,
+      to,
+      targetDir: dir,
+      autoFixSteps: fixableSteps.map((s) => ({
+        component: s.component,
+        description: s.description,
+        searchPattern: s.searchPattern,
+        before: s.before,
+        after: s.after,
+        migrationGuide: s.migrationGuide
+      })),
+      manualSteps: manualSteps.map((s) => ({
+        component: s.component,
+        description: s.description,
+        guide: s.guide,
+        migrationGuide: s.migrationGuide,
+        before: s.before,
+        after: s.after
+      })),
+      summary: {
+        totalAutoFix: fixableSteps.length,
+        totalManual: manualSteps.length
+      }
+    }, "json");
+    return;
+  }
+  const lines = [];
+  lines.push(`# Auto-Migration Prompt: antd v${from} \u2192 v${to}`);
+  lines.push(`# Target directory: ${dir}`);
+  lines.push("");
+  lines.push("## Instructions for Code Agent");
+  lines.push("");
+  lines.push(`Scan all .ts/.tsx/.js/.jsx files in \`${dir}\` and apply the following migrations.`);
+  lines.push("For each file changed, verify the fix compiles correctly before moving on.");
+  lines.push("");
+  if (fixableSteps.length > 0) {
+    lines.push("## Auto-fixable Changes");
+    lines.push("");
+    for (let i = 0; i < fixableSteps.length; i++) {
+      const step = fixableSteps[i];
+      lines.push(`### ${i + 1}. ${step.component}: ${step.description}`);
+      lines.push("");
+      if (step.searchPattern) {
+        lines.push(`**Search regex:** \`${step.searchPattern}\``);
+        lines.push("");
+      }
+      if (step.migrationGuide) {
+        lines.push(step.migrationGuide);
+        lines.push("");
+      }
+      if (step.before && step.after) {
+        lines.push("**Before:**");
+        lines.push("```tsx");
+        lines.push(step.before);
+        lines.push("```");
+        lines.push("**After:**");
+        lines.push("```tsx");
+        lines.push(step.after);
+        lines.push("```");
+        lines.push("");
+      }
+    }
+  }
+  if (manualSteps.length > 0) {
+    lines.push("## Manual Changes (require human review)");
+    lines.push("");
+    for (let i = 0; i < manualSteps.length; i++) {
+      const step = manualSteps[i];
+      lines.push(`### ${i + 1}. ${step.component}: ${step.description}`);
+      lines.push("");
+      if (step.migrationGuide) {
+        lines.push(step.migrationGuide);
+        lines.push("");
+      }
+      if (step.before && step.after) {
+        lines.push("**Before:**");
+        lines.push("```tsx");
+        lines.push(step.before);
+        lines.push("```");
+        lines.push("**After:**");
+        lines.push("```tsx");
+        lines.push(step.after);
+        lines.push("```");
+        lines.push("");
+      }
+      if (step.guide) {
+        lines.push(`**Reference:** ${step.guide}`);
+        lines.push("");
+      }
+    }
+  }
+  console.log(lines.join("\n"));
+}
+function groupByComponent(steps) {
+  const map = /* @__PURE__ */ new Map();
+  for (const step of steps) {
+    const arr = map.get(step.component) || [];
+    arr.push(step);
+    map.set(step.component, arr);
+  }
+  return map;
+}
+function registerMigrateCommand(program2) {
+  program2.command("migrate <from> <to>").description("Version migration guide with optional auto-fix").option("--component <name>", "Component-specific migration guide").option("--apply <dir>", "Generate migration prompts for scanning a directory").option("--confirm", "Confirm auto-fix (required with --apply)").action((from, to, cmdOpts) => {
+    const opts = program2.opts();
+    const key = `${from}-${to}`;
+    let steps = MIGRATION_GUIDES[key];
+    if (!steps) {
+      const err = createError(
+        ErrorCodes.INVALID_ARGUMENT,
+        `No migration guide available for v${from} \u2192 v${to}`,
+        `Available migrations: ${Object.keys(MIGRATION_GUIDES).map((k) => `v${k.replace("-", " \u2192 v")}`).join(", ")}`
+      );
+      printError(err, opts.format);
+      process.exitCode = 1;
+      return;
+    }
+    if (cmdOpts.component) {
+      steps = steps.filter((s) => s.component.toLowerCase() === cmdOpts.component.toLowerCase());
+      if (steps.length === 0) {
+        const err = createError(
+          ErrorCodes.COMPONENT_NOT_FOUND,
+          `No migration steps found for ${cmdOpts.component} from v${from} to v${to}`
+        );
+        printError(err, opts.format);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    if (cmdOpts.apply) {
+      formatApplyPrompt(from, to, steps, cmdOpts.apply, opts.format);
+      return;
+    }
+    switch (opts.format) {
+      case "json":
+        formatJson(from, to, steps);
+        break;
+      case "markdown":
+        formatMarkdown(from, to, steps);
+        break;
+      case "text":
+      default:
+        formatText(from, to, steps);
+        break;
+    }
+  });
+}
+
+// src/index.ts
+var CLI_VERSION = "0.1.0";
+var program = new Command();
+program.name("antd").description("CLI tool for querying antd knowledge and analyzing antd usage").option("--format <format>", "Output format: json, text, or markdown", "text").option("--version <version>", "Target antd version (e.g. 5.20.0)").option("--lang <lang>", "Output language: en or zh", "en").option("--detail", "Full information output", false);
+program.addOption(new Option("-V, --cli-version", "Output the CLI version number"));
+registerListCommand(program);
+registerInfoCommand(program);
+registerDemoCommand(program);
+registerTokenCommand(program);
+registerSemanticCommand(program);
+registerChangelogCommand(program);
+registerDoctorCommand(program);
+registerUsageCommand(program);
+registerLintCommand(program);
+registerMigrateCommand(program);
+var idx = process.argv.indexOf("-V");
+var idx2 = process.argv.indexOf("--cli-version");
+if (idx !== -1 || idx2 !== -1) {
+  console.log(CLI_VERSION);
+  process.exit(0);
+}
+program.parse();
+//# sourceMappingURL=index.js.map