@ant-design/cli 6.3.3 → 6.3.5-beta.0

package/dist/index.js

@@ -8,17 +8,88 @@ import { readFileSync, existsSync } from "fs";
 import { gunzipSync } from "zlib";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+
+// 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",
+  TITLE_REQUIRED: "TITLE_REQUIRED",
+  GH_NOT_FOUND: "GH_NOT_FOUND",
+  GH_SUBMIT_FAILED: "GH_SUBMIT_FAILED",
+  DOC_NOT_AVAILABLE: "DOC_NOT_AVAILABLE",
+  UNKNOWN_TOOL: "UNKNOWN_TOOL"
+};
+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 <= 3) {
+      const sameFirstLetter = lower[0] === candidate[0]?.toLowerCase();
+      const bestSameFirstLetter = best ? lower[0] === best[0]?.toLowerCase() : false;
+      if (dist < bestDist || dist === bestDist && sameFirstLetter && !bestSameFirstLetter) {
+        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/data/loader.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
+var cachedDataPath;
 function getDataPath() {
+  if (cachedDataPath) return cachedDataPath;
   const candidates = [
     join(__dirname, "..", "data"),
     // from dist/
     join(__dirname, "..", "..", "data")
     // from src/data/
   ];
-  return candidates.find(
+  cachedDataPath = candidates.find(
     (p) => existsSync(join(p, "v5.json.gz")) || existsSync(join(p, "v5.json"))
   ) ?? candidates[0];
+  return cachedDataPath;
 }
 function readDataFile(filePath) {
   const gzPath = filePath + ".gz";
@@ -54,7 +125,15 @@ function loadMetadata(majorVersion) {
     };
   }
 }
+var metadataCache = /* @__PURE__ */ new Map();
 function loadMetadataForVersion(version) {
+  const cached = metadataCache.get(version);
+  if (cached) return cached;
+  const result = loadMetadataForVersionUncached(version);
+  metadataCache.set(version, result);
+  return result;
+}
+function loadMetadataForVersionUncached(version) {
   const parts = version.split(".");
   const major = parts[0];
   const majorVersion = `v${major}`;
@@ -105,6 +184,20 @@ function findComponent(store, name) {
 function getAllComponentNames(store) {
   return store.components.map((c) => c.name);
 }
+function resolveComponent(component, version) {
+  const store = loadMetadataForVersion(version);
+  const comp = findComponent(store, component);
+  if (!comp) {
+    const names = getAllComponentNames(store);
+    const suggestion = fuzzyMatch(component, names);
+    return createError(
+      ErrorCodes.COMPONENT_NOT_FOUND,
+      `Component '${component}' not found`,
+      suggestion ? `Did you mean '${suggestion}'?` : void 0
+    );
+  }
+  return { store, comp };
+}
 
 // src/data/version.ts
 import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
@@ -281,24 +374,32 @@ function output(data, format) {
 }
 
 // src/commands/list.ts
+function listComponents(opts) {
+  const store = loadMetadataForVersion(opts.version);
+  return store.components.map((c) => ({
+    name: c.name,
+    nameZh: c.nameZh ?? "",
+    description: c.description,
+    descriptionZh: c.descriptionZh ?? "",
+    since: c.since ?? "",
+    category: c.category ?? ""
+  }));
+}
 function registerListCommand(program2) {
   program2.command("list").description("List all components with bilingual names, descriptions, and first-supported version").action(() => {
     const opts = program2.opts();
     const versionInfo = detectVersion(opts.version);
-    const store = loadMetadataForVersion(versionInfo.version);
-    if (store.components.length === 0) {
-      console.log("No component data available.");
+    const components = listComponents({ version: versionInfo.version });
+    if (components.length === 0) {
+      if (opts.format === "json") {
+        output([], "json");
+      } else {
+        console.log("No component data available.");
+      }
       return;
     }
     if (opts.format === "json") {
-      const data = store.components.map((c) => ({
-        name: c.name,
-        nameZh: c.nameZh ?? "",
-        description: c.description,
-        descriptionZh: c.descriptionZh ?? "",
-        since: c.since ?? ""
-      }));
-      output(data, "json");
+      output(components, "json");
       return;
     }
     if (opts.format === "markdown") {
@@ -308,19 +409,19 @@ function registerListCommand(program2) {
         "| Component | \u7EC4\u4EF6\u540D | Description | Since |",
         "|-----------|--------|-------------|-------|"
       ];
-      for (const c of store.components) {
+      for (const c of components) {
         const desc = c.description || c.descriptionZh || "";
-        lines.push(`| **${c.name}** | ${c.nameZh ?? ""} | ${desc} | ${c.since ?? ""} |`);
+        lines.push(`| **${c.name}** | ${c.nameZh} | ${desc} | ${c.since} |`);
       }
       console.log(lines.join("\n"));
       return;
     }
     const headers = ["Component", "\u7EC4\u4EF6\u540D", "Description", "Since"];
-    const rows = store.components.map((c) => [
+    const rows = components.map((c) => [
       c.name,
-      c.nameZh ?? "",
+      c.nameZh,
       c.description,
-      c.since ?? ""
+      c.since
     ]);
     console.log(formatTable(headers, rows, "text"));
   });
@@ -332,393 +433,324 @@ function localize(en, zh, lang) {
   return en || "";
 }
 
-// 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",
-  TITLE_REQUIRED: "TITLE_REQUIRED",
-  GH_NOT_FOUND: "GH_NOT_FOUND",
-  GH_SUBMIT_FAILED: "GH_SUBMIT_FAILED"
-};
-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 <= 3) {
-      const sameFirstLetter = lower[0] === candidate[0]?.toLowerCase();
-      const bestSameFirstLetter = best ? lower[0] === best[0]?.toLowerCase() : false;
-      if (dist < bestDist || dist === bestDist && sameFirstLetter && !bestSameFirstLetter) {
-        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 mapProps(props, lang, detail) {
-  return props.map(
-    (p) => detail ? [p.name, p.type, p.default, p.since ?? "-", localize(p.description, p.descriptionZh, lang) || "-"] : [p.name, p.type, p.default, p.since ?? "-"]
-  );
+function getComponentInfo(component, opts) {
+  const resolved = resolveComponent(component, opts.version);
+  if ("error" in resolved) return resolved;
+  const { comp } = resolved;
+  const desc = localize(comp.description, comp.descriptionZh, opts.lang);
+  const whenToUse = localize(comp.whenToUse, comp.whenToUseZh, opts.lang);
+  if (opts.detail) {
+    return {
+      name: comp.name,
+      nameZh: comp.nameZh ?? "",
+      description: desc,
+      whenToUse: whenToUse || "",
+      props: comp.props.map((p) => ({
+        ...p,
+        description: localize(p.description, p.descriptionZh, opts.lang)
+      })),
+      subComponentProps: comp.subComponentProps ? Object.fromEntries(
+        Object.entries(comp.subComponentProps).map(([name, props]) => [
+          name,
+          props.map((p) => ({ ...p, description: localize(p.description, p.descriptionZh, opts.lang) }))
+        ])
+      ) : void 0,
+      methods: comp.methods || [],
+      related: comp.related || [],
+      faq: comp.faq || []
+    };
+  }
+  return {
+    name: comp.name,
+    nameZh: comp.nameZh ?? "",
+    description: desc,
+    props: comp.props.map((p) => ({
+      name: p.name,
+      type: p.type,
+      default: p.default,
+      since: p.since ?? ""
+    })),
+    subComponentProps: comp.subComponentProps ? Object.fromEntries(
+      Object.entries(comp.subComponentProps).map(([name, props]) => [
+        name,
+        props.map((p) => ({ name: p.name, type: p.type, default: p.default }))
+      ])
+    ) : void 0
+  };
 }
 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 = loadMetadataForVersion(versionInfo.version);
-    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);
+    const result = getComponentInfo(component, {
+      lang,
+      version: versionInfo.version,
+      detail: opts.detail
+    });
+    if ("error" in result) {
+      printError(result, 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,
-            nameZh: comp.nameZh ?? "",
-            description: desc,
-            whenToUse: whenToUse || "",
-            props: comp.props.map((p) => ({
-              ...p,
-              description: localize(p.description, p.descriptionZh, lang)
-            })),
-            subComponentProps: comp.subComponentProps ? Object.fromEntries(
-              Object.entries(comp.subComponentProps).map(([name, props]) => [
-                name,
-                props.map((p) => ({ ...p, description: localize(p.description, p.descriptionZh, lang) }))
-              ])
-            ) : void 0,
-            methods: comp.methods || [],
-            related: comp.related || [],
-            faq: comp.faq || []
-          },
-          "json"
-        );
-      } else {
-        output(
-          {
-            name: comp.name,
-            nameZh: comp.nameZh ?? "",
-            description: desc,
-            props: comp.props.map((p) => ({
-              name: p.name,
-              type: p.type,
-              default: p.default,
-              since: p.since ?? ""
-            })),
-            subComponentProps: comp.subComponentProps ? Object.fromEntries(
-              Object.entries(comp.subComponentProps).map(([name, props]) => [
-                name,
-                props.map((p) => ({ name: p.name, type: p.type, default: p.default }))
-              ])
-            ) : void 0
-          },
-          "json"
-        );
-      }
+      output(result, "json");
       return;
     }
     const fmt = opts.format === "markdown" ? "markdown" : "text";
-    const nameLabel = comp.nameZh ? `${comp.name} (${comp.nameZh})` : comp.name;
-    console.log(`${nameLabel} \u2014 ${desc}`);
-    if (opts.detail && whenToUse) {
+    const nameLabel = result.nameZh ? `${result.name} (${result.nameZh})` : result.name;
+    console.log(`${nameLabel} \u2014 ${result.description}`);
+    if (opts.detail && "whenToUse" in result && result.whenToUse) {
       console.log(`
-When to use: ${whenToUse}`);
+When to use: ${result.whenToUse}`);
     }
     console.log("");
     const headers = opts.detail ? ["Property", "Type", "Default", "Since", "Description"] : ["Property", "Type", "Default", "Since"];
-    console.log(formatTable(headers, mapProps(comp.props, lang, opts.detail), fmt));
-    if (comp.subComponentProps) {
-      for (const [subName, subProps] of Object.entries(comp.subComponentProps)) {
+    const rows = result.props.map((p) => {
+      const s = "since" in p && p.since ? String(p.since) : "-";
+      return opts.detail && "description" in p ? [p.name, p.type, p.default, s, p.description || "-"] : [p.name, p.type, p.default, s];
+    });
+    console.log(formatTable(headers, rows, fmt));
+    if (result.subComponentProps) {
+      for (const [subName, subProps] of Object.entries(result.subComponentProps)) {
         console.log(`
 ${subName}`);
         console.log("");
-        console.log(formatTable(headers, mapProps(subProps, lang, opts.detail), fmt));
+        const subRows = subProps.map((p) => {
+          const prop = p;
+          return opts.detail ? [prop.name, prop.type, prop.default, prop.since || "-", prop.description || "-"] : [prop.name, prop.type, prop.default, prop.since || "-"];
+        });
+        console.log(formatTable(headers, subRows, fmt));
       }
     }
-    if (opts.detail && comp.related && comp.related.length > 0) {
+    if (opts.detail && "related" in result && result.related.length > 0) {
       console.log(`
-Related: ${comp.related.join(", ")}`);
+Related: ${result.related.join(", ")}`);
     }
   });
 }
 
 // src/commands/doc.ts
+function getComponentDoc(component, opts) {
+  const resolved = resolveComponent(component, opts.version);
+  if ("error" in resolved) return resolved;
+  const { comp } = resolved;
+  const doc = localize(comp.doc, comp.docZh, opts.lang);
+  if (!doc) {
+    return createError(
+      ErrorCodes.DOC_NOT_AVAILABLE,
+      `Documentation not available for '${comp.name}'`,
+      "Try upgrading to a newer version of the CLI"
+    );
+  }
+  return { name: comp.name, doc };
+}
 function registerDocCommand(program2) {
   program2.command("doc <component>").description("Output the full API documentation for a component in markdown").action((component) => {
     const opts = program2.opts();
     const lang = opts.lang;
     const versionInfo = detectVersion(opts.version);
-    const store = loadMetadataForVersion(versionInfo.version);
-    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 doc = localize(comp.doc, comp.docZh, lang);
-    if (!doc) {
-      const err = createError(
-        "DOC_NOT_AVAILABLE",
-        `Documentation not available for '${comp.name}'`,
-        "Try upgrading to a newer version of the CLI"
-      );
-      printError(err, opts.format);
+    const result = getComponentDoc(component, {
+      lang,
+      version: versionInfo.version
+    });
+    if ("error" in result) {
+      printError(result, opts.format);
       process.exitCode = 1;
       return;
     }
     if (opts.format === "json") {
-      output({ name: comp.name, doc }, "json");
+      output({ name: result.name, doc: result.doc }, "json");
       return;
     }
-    process.stdout.write(doc + "\n");
+    process.stdout.write(result.doc + "\n");
   });
 }
 
 // src/commands/demo.ts
+function getComponentDemo(component, opts) {
+  const resolved = resolveComponent(component, opts.version);
+  if ("error" in resolved) return resolved;
+  const { comp } = resolved;
+  const demos = comp.demos || [];
+  if (!opts.name) {
+    return {
+      component: comp.name,
+      demos: demos.map((d) => ({
+        name: d.name,
+        title: d.title,
+        description: d.description
+      }))
+    };
+  }
+  const demo = demos.find((d) => d.name.toLowerCase() === opts.name.toLowerCase());
+  if (!demo) {
+    const demoNames = demos.map((d) => d.name);
+    const suggestion = fuzzyMatch(opts.name, demoNames);
+    return createError(
+      ErrorCodes.DEMO_NOT_FOUND,
+      `Demo '${opts.name}' not found for ${comp.name}`,
+      suggestion ? `Did you mean '${suggestion}'?` : `Available demos: ${demoNames.join(", ") || "none"}`
+    );
+  }
+  return {
+    component: comp.name,
+    demo: demo.name,
+    title: demo.title,
+    description: demo.description,
+    code: demo.code
+  };
+}
 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 = loadMetadataForVersion(versionInfo.version);
-    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);
+    const result = getComponentDemo(component, {
+      version: versionInfo.version,
+      name
+    });
+    if ("error" in result) {
+      printError(result, opts.format);
       process.exitCode = 1;
       return;
     }
-    const demos = comp.demos || [];
-    if (!name) {
+    if ("code" in result) {
       if (opts.format === "json") {
-        output(
-          {
-            component: comp.name,
-            demos: demos.map((d) => ({
-              name: d.name,
-              title: d.title,
-              description: d.description
-            }))
-          },
-          "json"
-        );
+        output(result, "json");
+      } else {
+        console.log(`${result.component} / ${result.title}`);
+        console.log(`${result.description}`);
+        console.log("");
+        console.log(result.code);
+      }
+    } else {
+      if (opts.format === "json") {
+        output(result, "json");
       } else {
-        console.log(`${comp.name} Demos:`);
+        console.log(`${result.component} Demos:`);
         console.log("");
-        for (const demo2 of demos) {
-          console.log(`  ${demo2.name} \u2014 ${demo2.title}`);
-          console.log(`    ${demo2.description}`);
+        for (const demo of result.demos) {
+          console.log(`  ${demo.name} \u2014 ${demo.title}`);
+          console.log(`    ${demo.description}`);
         }
-        if (demos.length === 0) {
+        if (result.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 getTokens(component, opts) {
+  const major = `v${opts.version.split(".")[0]}`;
+  if (major === "v4") {
+    return createError(
+      ErrorCodes.UNSUPPORTED_VERSION_FEATURE,
+      "Design Token system is not available in antd v4",
+      "Upgrade to antd v5+ to use Design Tokens"
+    );
+  }
+  if (!component) {
+    const store = loadMetadataForVersion(opts.version);
+    const globalTokens = store.globalTokens || [];
+    return { tokens: globalTokens };
+  }
+  const resolved = resolveComponent(component, opts.version);
+  if ("error" in resolved) return resolved;
+  const { comp } = resolved;
+  const tokens = comp.tokens || [];
+  return { component: comp.name, tokens };
+}
 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);
+    const result = getTokens(component, {
+      lang: opts.lang,
+      version: versionInfo.version
+    });
+    if ("error" in result) {
+      printError(result, opts.format);
       process.exitCode = 1;
       return;
     }
-    const store = loadMetadataForVersion(versionInfo.version);
-    if (!component) {
-      const globalTokens = store.globalTokens || [];
-      if (globalTokens.length === 0) {
+    if ("component" in result) {
+      if (result.tokens.length === 0) {
+        console.log(`No component tokens available for ${result.component}.`);
+        return;
+      }
+      if (opts.format === "json") {
+        output(result, "json");
+        return;
+      }
+      console.log(`${result.component} Component Tokens:`);
+      console.log("");
+      const headers = ["Token", "Type", "Default"];
+      const rows = result.tokens.map((t) => [t.name, t.type, t.default]);
+      console.log(formatTable(headers, rows, opts.format === "markdown" ? "markdown" : "text"));
+    } else {
+      if (result.tokens.length === 0) {
         console.log("No global token data available.");
         return;
       }
       if (opts.format === "json") {
-        output({ tokens: globalTokens }, "json");
+        output(result, "json");
         return;
       }
       console.log("Global Design Tokens:");
       console.log("");
-      const headers2 = ["Token", "Type", "Default", "Description"];
-      const rows2 = globalTokens.map((t) => [
+      const headers = ["Token", "Type", "Default", "Description"];
+      const rows = result.tokens.map((t) => [
         t.name,
         t.type,
         t.default,
         localize(t.description, t.descriptionZh, opts.lang) || "-"
       ]);
-      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;
+      console.log(formatTable(headers, rows, opts.format === "markdown" ? "markdown" : "text"));
     }
-    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 getSemanticStructure(component, opts) {
+  const resolved = resolveComponent(component, opts.version);
+  if ("error" in resolved) return resolved;
+  const { comp } = resolved;
+  const structure = comp.semanticStructure || [];
+  return { name: comp.name, semanticStructure: structure };
+}
 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 = loadMetadataForVersion(versionInfo.version);
-    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);
+    const result = getSemanticStructure(component, {
+      version: versionInfo.version
+    });
+    if ("error" in result) {
+      printError(result, opts.format);
       process.exitCode = 1;
       return;
     }
-    const structure = comp.semanticStructure || [];
-    if (structure.length === 0) {
-      console.log(`No semantic structure data available for ${comp.name}.`);
+    if (result.semanticStructure.length === 0) {
+      console.log(`No semantic structure data available for ${result.name}.`);
       return;
     }
     if (opts.format === "json") {
-      output({ name: comp.name, semanticStructure: structure }, "json");
+      output(result, "json");
       return;
     }
-    console.log(`${comp.name} Semantic Structure:`);
+    console.log(`${result.name} Semantic Structure:`);
+    const structure = result.semanticStructure;
     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' } }} />`);
+    console.log(`  <${result.name} classNames={{ ${structure[0]?.key}: 'my-${structure[0]?.key}' }} />`);
+    console.log(`  <${result.name} styles={{ ${structure[0]?.key}: { background: '#fff' } }} />`);
   });
 }
 
@@ -748,21 +780,6 @@ var EMOJI_MAP = {
   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 diffProps(oldProps, newProps) {
   const oldMap = new Map(oldProps.map((p) => [p.name, p]));
   const newMap = new Map(newProps.map((p) => [p.name, p]));
@@ -789,32 +806,53 @@ function diffProps(oldProps, newProps) {
   }
   return { added, removed, changed };
 }
-function runApiDiff(v1, v2, component, opts) {
-  const store1 = loadMetadataForVersion(v1);
-  const store2 = loadMetadataForVersion(v2);
+function queryChangelog(opts) {
+  const store = loadMetadataForVersion(opts.snapshotVersion);
+  const changelog = store.changelog || [];
+  if (changelog.length === 0) {
+    return createError(
+      ErrorCodes.VERSION_NOT_FOUND,
+      "No changelog data available"
+    );
+  }
+  const entries = filterEntries(changelog, opts.entryFilter);
+  if (entries.length === 0) {
+    return createError(
+      ErrorCodes.VERSION_NOT_FOUND,
+      `No changelog entries found for "${opts.entryFilter}"`,
+      `Available versions: ${changelog.map((e) => e.version).join(", ")}`
+    );
+  }
+  return { entries, versionArg: opts.entryFilter };
+}
+function diffChangelog(opts) {
+  if (compare(opts.v1, opts.v2) > 0) {
+    return createError(
+      ErrorCodes.INVALID_ARGUMENT,
+      `Version order is invalid: "${opts.v1}" is newer than "${opts.v2}"`,
+      `Swap the versions: v1=${opts.v2}, v2=${opts.v1}`
+    );
+  }
+  const store1 = loadMetadataForVersion(opts.v1);
+  const store2 = loadMetadataForVersion(opts.v2);
   if (store1.components.length === 0) {
-    printError(createError(ErrorCodes.VERSION_NOT_FOUND, `No data available for version ${v1}`), opts.format);
-    process.exitCode = 1;
-    return;
+    return createError(ErrorCodes.VERSION_NOT_FOUND, `No data available for version ${opts.v1}`);
   }
   if (store2.components.length === 0) {
-    printError(createError(ErrorCodes.VERSION_NOT_FOUND, `No data available for version ${v2}`), opts.format);
-    process.exitCode = 1;
-    return;
+    return createError(ErrorCodes.VERSION_NOT_FOUND, `No data available for version ${opts.v2}`);
   }
-  const componentsToCompare = component ? [component] : [.../* @__PURE__ */ new Set([...getAllComponentNames(store1), ...getAllComponentNames(store2)])];
-  if (component) {
-    const c1 = findComponent(store1, component);
-    const c2 = findComponent(store2, component);
+  const componentsToCompare = opts.component ? [opts.component] : [.../* @__PURE__ */ new Set([...getAllComponentNames(store1), ...getAllComponentNames(store2)])];
+  if (opts.component) {
+    const c1 = findComponent(store1, opts.component);
+    const c2 = findComponent(store2, opts.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
+      const suggestion = fuzzyMatch(opts.component, allNames);
+      return createError(
+        ErrorCodes.COMPONENT_NOT_FOUND,
+        `Component '${opts.component}' not found in either version`,
+        suggestion ? `Did you mean '${suggestion}'?` : void 0
       );
-      process.exitCode = 1;
-      return;
     }
   }
   const diffs = [];
@@ -832,18 +870,36 @@ function runApiDiff(v1, v2, component, opts) {
       }
     }
   }
-  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 { from: opts.v1, to: opts.v2, diffs, component: opts.component };
+}
+function printChangelogEntries(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 printApiDiff(result, format) {
+  if (format === "json") {
+    const jsonResult = result.component && result.diffs.length > 0 ? { from: result.from, to: result.to, ...result.diffs[0] } : { from: result.from, to: result.to, diffs: result.diffs };
+    output(jsonResult, "json");
     return;
   }
-  if (diffs.length === 0) {
-    console.log(`No API differences found between ${v1} and ${v2}.`);
+  if (result.diffs.length === 0) {
+    console.log(`No API differences found between ${result.from} and ${result.to}.`);
     return;
   }
-  console.log(`API Diff: ${v1} \u2192 ${v2}`);
+  console.log(`API Diff: ${result.from} \u2192 ${result.to}`);
   console.log("");
-  for (const diff of diffs) {
+  for (const diff of result.diffs) {
     console.log(`  ${diff.component}:`);
     for (const p of diff.added) console.log(`    + ${p.name}: ${p.type}`);
     for (const p of diff.removed) {
@@ -862,36 +918,28 @@ function registerChangelogCommand(program2) {
       const v1ForDetect = v1?.includes("..") ? v1.split("..")[1] : v1;
       const versionForDetect = opts.version ?? (v1ForDetect && /^\d+\.\d+\.\d+$/.test(v1ForDetect) ? v1ForDetect : void 0);
       const versionInfo = detectVersion(versionForDetect);
-      const store = loadMetadataForVersion(versionInfo.version);
-      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);
+      const result = queryChangelog({
+        snapshotVersion: versionInfo.version,
+        entryFilter: v1
+      });
+      if ("error" in result) {
+        if (result.code === ErrorCodes.VERSION_NOT_FOUND && !result.suggestion) {
+          console.log("No changelog data available.");
+          return;
+        }
+        printError(result, opts.format);
         process.exitCode = 1;
         return;
       }
-      printChangelog(entries, opts.format, v1);
+      printChangelogEntries(result.entries, opts.format, result.versionArg);
     } 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);
+      const result = diffChangelog({ v1, v2, component });
+      if ("error" in result) {
+        printError(result, opts.format);
         process.exitCode = 1;
         return;
       }
-      runApiDiff(v1, v2, component, opts);
+      printApiDiff(result, opts.format);
     }
   });
 }
@@ -905,7 +953,6 @@ 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"]);
-var ANTD_IMPORT_RE = /import\s+\{([^}]+)\}\s+from\s+['"]antd(?:\/[^'"]*)?['"]/g;
 function collectFiles(dir) {
   const files = [];
   try {
@@ -929,15 +976,14 @@ function collectFiles(dir) {
   }
   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((n) => Boolean(n) && !/^type\s/.test(n));
-    names.push(...parsed);
+function getJSXElementName(name) {
+  if (name.type === "JSXMemberExpression") {
+    return getJSXElementName(name.object) + "." + name.property.name;
   }
-  return names;
+  if (name.type === "JSXIdentifier") {
+    return name.name;
+  }
+  return "";
 }
 function readJson(path) {
   try {
@@ -1317,7 +1363,7 @@ function registerDoctorCommand(program2) {
 
 // src/commands/usage.ts
 import { readFileSync as readFileSync5 } from "fs";
-var SUB_COMPONENT_RE = /\b(\w+)\.(\w+)\b/g;
+import { parseSync, Visitor } from "oxc-parser";
 function scanFile(filePath) {
   const result = /* @__PURE__ */ new Map();
   let content;
@@ -1326,23 +1372,43 @@ function scanFile(filePath) {
   } 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) && /^[A-Z]/.test(child)) {
-      const entry = result.get(parent);
-      const subKey = `${parent}.${child}`;
-      entry.subComponents.set(subKey, (entry.subComponents.get(subKey) || 0) + 1);
+  if (!content.includes("antd")) return result;
+  const parsed = parseSync(filePath, content);
+  if (parsed.errors.length > 0) return result;
+  const importedNames = /* @__PURE__ */ new Set();
+  const visitor = new Visitor({
+    ImportDeclaration(node) {
+      const source = node.source.value;
+      if (source !== "antd" && !source.startsWith("antd/")) return;
+      if (node.importKind === "type") return;
+      for (const spec of node.specifiers) {
+        if (spec.type === "ImportSpecifier") {
+          if (spec.importKind === "type") continue;
+          const name = spec.imported?.name || spec.local?.name;
+          if (name) {
+            importedNames.add(name);
+            if (!result.has(name)) {
+              result.set(name, { count: 0, subComponents: /* @__PURE__ */ new Map() });
+            }
+            result.get(name).count++;
+          }
+        }
+      }
+    },
+    // Detect sub-component JSX usage: <Form.Item>, <Table.Column>, etc.
+    JSXOpeningElement(node) {
+      const fullName = getJSXElementName(node.name);
+      if (!fullName.includes(".")) return;
+      const [parent] = fullName.split(".");
+      if (importedNames.has(parent)) {
+        const entry = result.get(parent);
+        if (entry) {
+          entry.subComponents.set(fullName, (entry.subComponents.get(fullName) || 0) + 1);
+        }
+      }
     }
-  }
+  });
+  visitor.visit(parsed.program);
   return result;
 }
 function registerUsageCommand(program2) {
@@ -1429,9 +1495,7 @@ Non-component antd exports (${nonComponents.length}):`);
 
 // src/commands/lint.ts
 import { readFileSync as readFileSync6 } from "fs";
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+import { parseSync as parseSync2, Visitor as Visitor2 } from "oxc-parser";
 function getDeprecatedProps(store) {
   const result = /* @__PURE__ */ new Map();
   for (const comp of store.components) {
@@ -1450,248 +1514,197 @@ function getDeprecatedProps(store) {
   }
   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;
+function findAttr(attrs, name) {
+  return attrs.find((a) => a.type === "JSXAttribute" && a.name?.name === name) ?? null;
+}
+function hasAttr(attrs, name) {
+  return findAttr(attrs, name) !== null;
+}
+function getStringAttrValue(attrs, name) {
+  const a = findAttr(attrs, name);
+  if (!a) return null;
+  if (a.value?.type === "Literal" && typeof a.value.value === "string") {
+    return a.value.value;
+  }
+  if (a.value?.type === "JSXExpressionContainer" && a.value.expression?.type === "Literal" && typeof a.value.expression.value === "string") {
+    return a.value.expression.value;
+  }
+  return null;
+}
+function isBooleanFalse(attrs, name) {
+  const a = findAttr(attrs, name);
+  if (!a) return false;
+  return a.value?.type === "JSXExpressionContainer" && a.value.expression?.type === "Literal" && a.value.expression.value === false;
+}
+function isObjectExpression(attrs, name) {
+  const a = findAttr(attrs, name);
+  if (!a) return false;
+  return a.value?.type === "JSXExpressionContainer" && a.value.expression?.type === "ObjectExpression";
+}
+function getObjectExpressionKeys(attrs, name) {
+  const a = findAttr(attrs, name);
+  if (!a) return [];
+  if (a.value?.type === "JSXExpressionContainer" && a.value.expression?.type === "ObjectExpression") {
+    return a.value.expression.properties.filter((p) => p.type === "Property" && p.key).map((p) => p.key.name || p.key.value).filter(Boolean);
   }
-  return false;
+  return [];
 }
 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 hasSelect = importedComponents.includes("Select") || importedComponents.includes("TreeSelect");
-  const hasButton = importedComponents.includes("Button");
-  const hasCheckbox = importedComponents.includes("Checkbox");
-  const hasDivider = importedComponents.includes("Divider");
-  const hasMenu = importedComponents.includes("Menu");
-  const hasQRCode = importedComponents.includes("QRCode");
-  const hasRadio = importedComponents.includes("Radio");
-  const hasTreeSelect = importedComponents.includes("TreeSelect");
-  const hasTypography = importedComponents.includes("Typography");
-  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 === "deprecated") {
-      if (/<BackTop\b/.test(line)) {
-        issues.push({
-          file: filePath,
-          line: i + 1,
-          rule: "deprecated",
-          severity: "warning",
-          message: "`BackTop` is deprecated, use `FloatButton.BackTop` instead"
-        });
-      }
-      if (hasButton && /<Button\.Group\b/.test(line)) {
-        issues.push({
-          file: filePath,
-          line: i + 1,
-          rule: "deprecated",
-          severity: "warning",
-          message: "`Button.Group` is deprecated, use `Space.Compact` instead"
-        });
-      }
-      if (/<Input\.Group\b/.test(line)) {
-        issues.push({
-          file: filePath,
-          line: i + 1,
-          rule: "deprecated",
-          severity: "warning",
-          message: "`Input.Group` is deprecated, use `Space.Compact` instead"
-        });
-      }
-    }
-    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 (!only || only === "usage") {
-      if (/Form\.Item\b/.test(line)) {
-        if (hasNearbyMatch(lines, i, 10, /shouldUpdate\s*[=]/) && hasNearbyMatch(lines, i, 10, /dependencies\s*[=]/)) {
-          issues.push({
-            file: filePath,
-            line: i + 1,
-            rule: "usage",
-            severity: "warning",
-            message: "`shouldUpdate` and `dependencies` should not be used together on Form.Item"
-          });
+  if (!content.includes("antd")) return [];
+  const result = parseSync2(filePath, content);
+  if (result.errors.length > 0) return [];
+  const issues = [];
+  const importedComponents = /* @__PURE__ */ new Set();
+  const report = (rule, severity, line, message) => {
+    issues.push({ file: filePath, line, rule, severity, message });
+  };
+  const visitor = new Visitor2({
+    ImportDeclaration(node) {
+      const source = node.source.value;
+      if (source !== "antd" && !source.startsWith("antd/")) return;
+      if (node.importKind === "type") return;
+      for (const spec of node.specifiers) {
+        if (spec.type === "ImportSpecifier") {
+          if (spec.importKind === "type") continue;
+          const name = spec.imported?.name || spec.local?.name;
+          if (name) importedComponents.add(name);
         }
-      }
-      if (hasButton && /<Button\b/.test(line)) {
-        if (hasNearbyMatch(lines, i, 5, /\bghost\b/) && hasNearbyMatch(lines, i, 5, /type\s*=\s*['"{](?:link|text)['"}\s]/)) {
-          issues.push({
-            file: filePath,
-            line: i + 1,
-            rule: "usage",
-            severity: "warning",
-            message: 'Button `ghost` prop cannot be used with `type="link"` or `type="text"`'
-          });
+        if ((!only || only === "performance") && (spec.type === "ImportDefaultSpecifier" || spec.type === "ImportNamespaceSpecifier")) {
+          report(
+            "performance",
+            "error",
+            node.loc?.start?.line ?? 0,
+            "Avoid wildcard import from antd. Use named imports: `import { Button } from 'antd'`"
+          );
         }
       }
-      if (hasCheckbox && /<Checkbox\b/.test(line) && !/Checkbox\.Group/.test(line)) {
-        if (hasNearbyMatch(lines, i, 5, /\bvalue\s*=/)) {
-          issues.push({
-            file: filePath,
-            line: i + 1,
-            rule: "usage",
-            severity: "warning",
-            message: "Checkbox `value` is not a valid prop outside Checkbox.Group, did you mean `checked`?"
-          });
+    },
+    JSXOpeningElement(node) {
+      const compName = getJSXElementName(node.name);
+      if (!compName) return;
+      const attrs = node.attributes || [];
+      const line = node.loc?.start?.line ?? 0;
+      if (!only || only === "deprecated") {
+        if (compName === "BackTop" && importedComponents.has("BackTop")) {
+          report("deprecated", "warning", line, "`BackTop` is deprecated, use `FloatButton.BackTop` instead");
         }
-      }
-      if (hasDivider && /<Divider\b/.test(line)) {
-        if (hasNearbyMatch(lines, i, 5, /type\s*=\s*['"{]vertical['"}]/) && (!hasNearbyMatch(lines, i, 3, /\/>/) || hasNearbyMatch(lines, i, 5, /\bchildren\s*=/))) {
-          issues.push({
-            file: filePath,
-            line: i + 1,
-            rule: "usage",
-            severity: "warning",
-            message: 'Divider `children` are not supported in `type="vertical"` mode'
-          });
+        if (compName === "Button.Group" && importedComponents.has("Button")) {
+          report("deprecated", "warning", line, "`Button.Group` is deprecated, use `Space.Compact` instead");
         }
-      }
-      if (hasSelect && /<Select\b/.test(line)) {
-        if (hasNearbyMatch(lines, i, 10, /maxCount\s*=/) && !hasNearbyMatch(lines, i, 10, /mode\s*=\s*['"{](?:multiple|tags)['"}]/)) {
-          issues.push({
-            file: filePath,
-            line: i + 1,
-            rule: "usage",
-            severity: "warning",
-            message: 'Select `maxCount` only works with `mode="multiple"` or `mode="tags"`'
-          });
+        if (compName === "Input.Group" && importedComponents.has("Input")) {
+          report("deprecated", "warning", line, "`Input.Group` is deprecated, use `Space.Compact` instead");
         }
-      }
-      if (hasMenu && /<Menu\b/.test(line)) {
-        if (hasNearbyMatch(lines, i, 10, /inlineCollapsed\s*=/) && !hasNearbyMatch(lines, i, 10, /mode\s*=\s*['"{]inline['"}]/)) {
-          issues.push({
-            file: filePath,
-            line: i + 1,
-            rule: "usage",
-            severity: "warning",
-            message: 'Menu `inlineCollapsed` should only be used with `mode="inline"`'
-          });
+        const baseName = compName.includes(".") ? compName.split(".")[0] : compName;
+        if (importedComponents.has(baseName) || importedComponents.has(compName)) {
+          const deprecations = deprecatedMap.get(compName);
+          if (deprecations) {
+            for (const attr of attrs) {
+              if (attr.type !== "JSXAttribute") continue;
+              const propName = attr.name?.name;
+              const dep = deprecations.find((d) => d.prop === propName);
+              if (dep) {
+                report("deprecated", "warning", attr.loc?.start?.line ?? line, `${compName} ${dep.message}`);
+              }
+            }
+          }
         }
       }
-      if (hasQRCode && /<QRCode\b/.test(line) && !hasNearbyMatch(lines, i, 10, /\bvalue\s*=/)) {
-        issues.push({
-          file: filePath,
-          line: i + 1,
-          rule: "usage",
-          severity: "warning",
-          message: "QRCode is missing required `value` prop"
-        });
-      }
-      if (hasTypography && /<Typography\.Link\b/.test(line)) {
-        if (hasNearbyMatch(lines, i, 5, /ellipsis\s*=\s*\{\{/)) {
-          issues.push({
-            file: filePath,
-            line: i + 1,
-            rule: "usage",
-            severity: "warning",
-            message: "Typography.Link `ellipsis` only supports boolean value, not object config"
-          });
+      if (!only || only === "a11y") {
+        if (compName === "Image" && importedComponents.has("Image")) {
+          if (!hasAttr(attrs, "alt")) {
+            report("a11y", "warning", line, "Image component is missing `alt` prop for accessibility");
+          }
         }
-      }
-      if (hasTypography && /<Typography\.Text\b/.test(line)) {
-        if (hasNearbyMatch(lines, i, 10, /ellipsis\s*=\s*\{\{/) && hasNearbyMatch(lines, i, 10, /\b(?:expandable|rows)\s*[=:]/)) {
-          issues.push({
-            file: filePath,
-            line: i + 1,
-            rule: "usage",
-            severity: "warning",
-            message: "Typography.Text `ellipsis` does not support `expandable` or `rows`"
-          });
+        if (compName.endsWith("Icon") && hasAttr(attrs, "onClick") && !hasAttr(attrs, "aria-label")) {
+          report("a11y", "warning", line, "Clickable icon should have `aria-label` for screen readers");
         }
       }
-      if (hasRadio && /<Radio\b/.test(line) && !/<Radio\.Group\b/.test(line)) {
-        if (hasNearbyMatch(lines, i, 5, /optionType\s*=/)) {
-          issues.push({
-            file: filePath,
-            line: i + 1,
-            rule: "usage",
-            severity: "warning",
-            message: "`optionType` is only supported on Radio.Group, not Radio"
-          });
+      if (!only || only === "usage") {
+        if (compName === "Form.Item" && importedComponents.has("Form")) {
+          if (hasAttr(attrs, "shouldUpdate") && hasAttr(attrs, "dependencies")) {
+            report("usage", "warning", line, "`shouldUpdate` and `dependencies` should not be used together on Form.Item");
+          }
         }
-      }
-      if (hasTreeSelect && /<TreeSelect\b/.test(line)) {
-        if (hasNearbyMatch(lines, i, 10, /multiple\s*=\s*\{?\s*false/) && hasNearbyMatch(lines, i, 10, /treeCheckable\b/)) {
-          issues.push({
-            file: filePath,
-            line: i + 1,
-            rule: "usage",
-            severity: "warning",
-            message: "TreeSelect `multiple={false}` is ignored when `treeCheckable` is true"
-          });
+        if (compName === "Button" && importedComponents.has("Button")) {
+          if (hasAttr(attrs, "ghost")) {
+            const typeVal = getStringAttrValue(attrs, "type");
+            if (typeVal === "link" || typeVal === "text") {
+              report("usage", "warning", line, 'Button `ghost` prop cannot be used with `type="link"` or `type="text"`');
+            }
+          }
+        }
+        if (compName === "Checkbox" && importedComponents.has("Checkbox")) {
+          if (hasAttr(attrs, "value")) {
+            report("usage", "warning", line, "Checkbox `value` is not a valid prop outside Checkbox.Group, did you mean `checked`?");
+          }
+        }
+        if (compName === "Divider" && importedComponents.has("Divider")) {
+          const typeVal = getStringAttrValue(attrs, "type");
+          if (typeVal === "vertical" && (!node.selfClosing || hasAttr(attrs, "children"))) {
+            report("usage", "warning", line, 'Divider `children` are not supported in `type="vertical"` mode');
+          }
+        }
+        if (compName === "Select" && importedComponents.has("Select")) {
+          if (hasAttr(attrs, "maxCount")) {
+            const modeVal = getStringAttrValue(attrs, "mode");
+            if (modeVal !== "multiple" && modeVal !== "tags") {
+              report("usage", "warning", line, 'Select `maxCount` only works with `mode="multiple"` or `mode="tags"`');
+            }
+          }
+        }
+        if (compName === "Menu" && importedComponents.has("Menu")) {
+          if (hasAttr(attrs, "inlineCollapsed")) {
+            const modeVal = getStringAttrValue(attrs, "mode");
+            if (modeVal !== "inline") {
+              report("usage", "warning", line, 'Menu `inlineCollapsed` should only be used with `mode="inline"`');
+            }
+          }
+        }
+        if (compName === "QRCode" && importedComponents.has("QRCode")) {
+          if (!hasAttr(attrs, "value")) {
+            report("usage", "warning", line, "QRCode is missing required `value` prop");
+          }
+        }
+        if (compName === "Typography.Link" && importedComponents.has("Typography")) {
+          if (isObjectExpression(attrs, "ellipsis")) {
+            report("usage", "warning", line, "Typography.Link `ellipsis` only supports boolean value, not object config");
+          }
+        }
+        if (compName === "Typography.Text" && importedComponents.has("Typography")) {
+          if (isObjectExpression(attrs, "ellipsis")) {
+            const keys = getObjectExpressionKeys(attrs, "ellipsis");
+            if (keys.includes("expandable") || keys.includes("rows")) {
+              report("usage", "warning", line, "Typography.Text `ellipsis` does not support `expandable` or `rows`");
+            }
+          }
+        }
+        if (compName === "Radio" && importedComponents.has("Radio")) {
+          if (hasAttr(attrs, "optionType")) {
+            report("usage", "warning", line, "`optionType` is only supported on Radio.Group, not Radio");
+          }
+        }
+        if (compName === "TreeSelect" && importedComponents.has("TreeSelect")) {
+          if (isBooleanFalse(attrs, "multiple") && hasAttr(attrs, "treeCheckable")) {
+            report("usage", "warning", line, "TreeSelect `multiple={false}` is ignored when `treeCheckable` is true");
+          }
         }
       }
-    }
-    if (!only || only === "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'`"
-        });
+      if (!only || only === "performance") {
+        if (compName === "Select" && importedComponents.has("Select") || compName === "TreeSelect" && importedComponents.has("TreeSelect")) {
+          if (isBooleanFalse(attrs, "virtual")) {
+            report("performance", "warning", line, "Disabling `virtual` scroll on Select may cause performance issues with large datasets");
+          }
+        }
       }
     }
-  }
+  });
+  visitor.visit(result.program);
   return issues;
 }
 function registerLintCommand(program2) {
@@ -2817,7 +2830,7 @@ function collectAntdEnv(cwd, versionOverride) {
 function collectCliEnv() {
   let cliVersion;
   try {
-    cliVersion = "6.3.3";
+    cliVersion = "6.3.5-beta.0";
   } catch (err) {
     console.error("Failed to get CLI version:", err);
     cliVersion = "unknown";
@@ -2837,7 +2850,7 @@ function buildAntdIssueBody(fields) {
   const expected = fields.expected || PLACEHOLDER;
   const actual = fields.actual || PLACEHOLDER;
   const extra = fields.extra || "";
-  let body = `<!-- generated by @ant-design/cli. DO NOT REMOVE -->
+  let body = `<!-- generated by ant-design-issue-helper. DO NOT REMOVE -->
 
 ### Reproduction link
 
@@ -3082,6 +3095,266 @@ function registerBugCliCommand(program2) {
   });
 }
 
+// src/commands/mcp.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/mcp/tools.ts
+function toMcpResult(data) {
+  if (data && typeof data === "object" && "error" in data && data.error === true) {
+    return { content: [{ type: "text", text: JSON.stringify(data) }], isError: true };
+  }
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+var TOOL_DEFINITIONS = [
+  {
+    name: "antd_list",
+    description: "List all available antd components with names, categories, and descriptions.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "antd_info",
+    description: "Get component API information including props, types, and default values.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        component: { type: "string", description: "Component name (e.g. Button, Table)" },
+        detail: { type: "boolean", description: "Include full detail (whenToUse, methods, related, faq)" }
+      },
+      required: ["component"]
+    }
+  },
+  {
+    name: "antd_doc",
+    description: "Get the full markdown documentation for a component.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        component: { type: "string", description: "Component name (e.g. Button, Table)" }
+      },
+      required: ["component"]
+    }
+  },
+  {
+    name: "antd_demo",
+    description: "Get demo source code for a component. Without a name, lists all demos; with a name, returns specific demo code.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        component: { type: "string", description: "Component name (e.g. Button, Table)" },
+        name: { type: "string", description: "Demo name to get specific demo code" }
+      },
+      required: ["component"]
+    }
+  },
+  {
+    name: "antd_token",
+    description: "Query design tokens. Without a component, returns global tokens; with a component, returns component-level tokens.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        component: { type: "string", description: "Component name for component-level tokens" }
+      },
+      required: []
+    }
+  },
+  {
+    name: "antd_semantic",
+    description: "Query the semantic customization structure (classNames/styles) of a component.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        component: { type: "string", description: "Component name (e.g. Button, Table)" }
+      },
+      required: ["component"]
+    }
+  },
+  {
+    name: "antd_changelog",
+    description: "Query changelog entries or diff API between two versions. Provide v1+v2 for diff mode, or version for changelog query mode.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        version: { type: "string", description: "Version or range filter for changelog query (e.g. 5.20.0 or 5.18.0..5.20.0)" },
+        v1: { type: "string", description: "Start version for API diff (e.g. 5.18.0)" },
+        v2: { type: "string", description: "End version for API diff (e.g. 5.20.0)" },
+        component: { type: "string", description: "Filter diff to a specific component" }
+      },
+      required: []
+    }
+  }
+];
+function createToolHandler(ctx) {
+  return async (name, params) => {
+    switch (name) {
+      case "antd_list": {
+        const components = listComponents({ version: ctx.version });
+        const trimmed = components.map(({ name: name2, nameZh, category, description }) => ({
+          name: name2,
+          nameZh,
+          category,
+          description
+        }));
+        return toMcpResult(trimmed);
+      }
+      case "antd_info": {
+        const result = getComponentInfo(params.component, {
+          lang: ctx.lang,
+          version: ctx.version,
+          detail: params.detail ?? false
+        });
+        return toMcpResult(result);
+      }
+      case "antd_doc": {
+        const result = getComponentDoc(params.component, {
+          lang: ctx.lang,
+          version: ctx.version
+        });
+        return toMcpResult(result);
+      }
+      case "antd_demo": {
+        const result = getComponentDemo(params.component, {
+          version: ctx.version,
+          name: params.name
+        });
+        return toMcpResult(result);
+      }
+      case "antd_token": {
+        const result = getTokens(params.component, {
+          lang: ctx.lang,
+          version: ctx.version
+        });
+        return toMcpResult(result);
+      }
+      case "antd_semantic": {
+        const result = getSemanticStructure(params.component, {
+          version: ctx.version
+        });
+        return toMcpResult(result);
+      }
+      case "antd_changelog": {
+        const v1 = params.v1;
+        const v2 = params.v2;
+        if (v1 && !v2 || !v1 && v2) {
+          return toMcpResult(
+            createError(
+              ErrorCodes.INVALID_ARGUMENT,
+              "Both v1 and v2 are required for diff mode",
+              "Provide both versions (v1 + v2), or omit both to use query mode"
+            )
+          );
+        }
+        if (v1 && v2) {
+          const result2 = diffChangelog({
+            v1,
+            v2,
+            component: params.component
+          });
+          return toMcpResult(result2);
+        }
+        const result = queryChangelog({
+          snapshotVersion: ctx.version,
+          entryFilter: params.version
+        });
+        return toMcpResult(result);
+      }
+      default:
+        return toMcpResult(
+          createError(ErrorCodes.UNKNOWN_TOOL, `Unknown tool: ${name}`)
+        );
+    }
+  };
+}
+
+// src/mcp/prompts.ts
+var SHARED_TOOL_WORKFLOW = `## Tool usage workflow
+1. Use **antd_list** to discover available components
+2. Use **antd_info** to get component props and API details
+3. Use **antd_doc** to read full component documentation
+4. Use **antd_demo** to get example code for a component
+
+## Additional tools
+- Use **antd_token** for querying design tokens (global or component-level) for theming
+- Use **antd_semantic** for querying semantic classNames/styles customization structure
+- Use **antd_changelog** for querying version changes and cross-version API diffs
+
+## Rules
+- Avoid duplicate tool calls \u2014 do not call the same tool with the same parameters twice
+- Always query component docs before generating code that uses the component
+- Prefer reading real documentation over guessing API usage`;
+var ANTD_EXPERT_PROMPT = `You are an expert assistant for Ant Design (antd), a React UI component library.
+
+${SHARED_TOOL_WORKFLOW}
+`;
+var ANTD_PAGE_GENERATOR_PROMPT = `You are an expert Ant Design page generator. Your job is to produce complete, runnable React pages using antd components.
+
+${SHARED_TOOL_WORKFLOW}
+- Before generating code, fetch ALL relevant component docs and examples
+- Produce complete, runnable code with all necessary imports
+- Include proper TypeScript types when applicable
+`;
+
+// src/commands/mcp.ts
+function registerMcpCommand(program2) {
+  program2.command("mcp").description("Start MCP (Model Context Protocol) server for AI assistant integration").action(async () => {
+    const opts = program2.opts();
+    const versionInfo = detectVersion(opts.version);
+    const server = new Server(
+      { name: "antd", version: "6.3.5-beta.0" },
+      { capabilities: { tools: {}, prompts: {} } }
+    );
+    const handleTool = createToolHandler({
+      version: versionInfo.version,
+      lang: opts.lang
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: TOOL_DEFINITIONS
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: params } = request.params;
+      return handleTool(name, params ?? {});
+    });
+    server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+      prompts: [
+        {
+          name: "antd-expert",
+          description: "General Ant Design expert assistant prompt"
+        },
+        {
+          name: "antd-page-generator",
+          description: "Ant Design page generation assistant prompt"
+        }
+      ]
+    }));
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+      const { name } = request.params;
+      if (name === "antd-expert") {
+        return {
+          messages: [{ role: "user", content: { type: "text", text: ANTD_EXPERT_PROMPT } }]
+        };
+      }
+      if (name === "antd-page-generator") {
+        return {
+          messages: [{ role: "user", content: { type: "text", text: ANTD_PAGE_GENERATOR_PROMPT } }]
+        };
+      }
+      throw new Error(`Unknown prompt: ${name}`);
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  });
+}
+
 // src/utils/update-check.ts
 import { readFileSync as readFileSync7, writeFileSync, mkdirSync, existsSync as existsSync3 } from "fs";
 import { join as join6 } from "path";
@@ -3157,7 +3430,7 @@ function printUpdateNotice(currentVersion, latestVersion) {
 }
 async function checkForUpdate() {
   if (process.env.CI || process.env.NO_UPDATE_CHECK) return;
-  const currentVersion = "6.3.3";
+  const currentVersion = "6.3.5-beta.0";
   if (!valid(currentVersion)) return;
   const now = Date.now();
   const cache = readCache();
@@ -3176,7 +3449,7 @@ async function checkForUpdate() {
 }
 
 // src/index.ts
-var CLI_VERSION = "6.3.3";
+var CLI_VERSION = "6.3.5-beta.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"));
@@ -3191,6 +3464,7 @@ registerDoctorCommand(program);
 registerUsageCommand(program);
 registerLintCommand(program);
 registerMigrateCommand(program);
+registerMcpCommand(program);
 registerBugCommand(program);
 registerBugCliCommand(program);
 program.hook("postAction", async () => {
@@ -3200,6 +3474,7 @@ var idx = process.argv.indexOf("-V");
 var idx2 = process.argv.indexOf("--cli-version");
 if (idx !== -1 || idx2 !== -1) {
   console.log(CLI_VERSION);
+  await checkForUpdate();
   process.exit(0);
 }
 program.parse();