@ant-design/cli 6.6.0 → 6.6.1

package/data/versions.json

@@ -68,6 +68,6 @@
     "6.2": "6.2.3",
     "6.4": "6.4.5",
     "6.5": "6.5.4",
-    "6.6": "6.6.0"
+    "6.6": "6.6.1"
   }
 }

package/dist/index.js

@@ -7970,7 +7970,12 @@ var require_fast_uri = __commonJS({
     }
     function resolve3(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent2(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
+      const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
+      const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
+      if (baseMalformed || relativeMalformed) {
+        throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+      }
+      const resolved = resolveComponent2(baseParsed, relativeParsed, schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
@@ -8096,6 +8101,7 @@ var require_fast_uri = __commonJS({
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
     var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+    var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
     function getParseError(parsed, matches) {
       if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
@@ -8130,6 +8136,20 @@ var require_fast_uri = __commonJS({
         parsed.error = "URI authority must not contain a literal backslash.";
         malformedAuthorityOrPort = true;
       }
+      const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+      if (introducerMatch !== null) {
+        const region = introducerMatch[1];
+        const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+        if (normalizedRegion.length >= 2) {
+          if (normalizedRegion.slice(0, 2) !== "//") {
+            parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+            malformedAuthorityOrPort = true;
+          } else if (region.length !== normalizedRegion.length) {
+            parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+            malformedAuthorityOrPort = true;
+          }
+        }
+      }
       const matches = uri.match(URI_PARSE);
       if (matches) {
         parsed.scheme = matches[1];
@@ -17478,6 +17498,28 @@ function getDeprecatedProps(store) {
   }
   return result;
 }
+function extractDeprecatedNotice(source) {
+  const notice = source?.match(
+    /:::warning\{\s*title\s*=\s*["']?(?:Deprecated Notice|废弃提示)["']?\s*\}\s*([\s\S]*?)\s*:::/
+  );
+  return notice?.[1]?.replace(/\s+/g, " ").trim();
+}
+function getDeprecatedComponents(store, lang) {
+  const result = /* @__PURE__ */ new Map();
+  for (const comp of store.components) {
+    const englishDetail = extractDeprecatedNotice(comp.whenToUse);
+    const chineseDetail = extractDeprecatedNotice(comp.whenToUseZh);
+    const englishMessage = englishDetail && `\`${comp.name}\` is deprecated. ${englishDetail}`;
+    const chineseMessage = chineseDetail && `\`${comp.name}\` \u5DF2\u5E9F\u5F03\u3002${chineseDetail}`;
+    const fallbackMessage = englishMessage ?? chineseMessage;
+    if (!fallbackMessage) continue;
+    result.set(
+      comp.name,
+      localize(englishMessage ?? fallbackMessage, chineseMessage ?? fallbackMessage, lang)
+    );
+  }
+  return result;
+}
 function findAttr(attrs, name) {
   return attrs.find((a) => a.type === "JSXAttribute" && a.name?.name === name) ?? null;
 }
@@ -17553,6 +17595,110 @@ function collectPatternNames(pattern, names = []) {
   }
   return names;
 }
+function collectScopeBindings(program2) {
+  const bindings = /* @__PURE__ */ new Map();
+  const scopeStack = [];
+  const pushScope = (node, kind) => {
+    bindings.set(node, /* @__PURE__ */ new Set());
+    scopeStack.push({ node, kind });
+  };
+  const declareIn = (scope, pattern) => {
+    const names = bindings.get(scope.node);
+    for (const name of collectPatternNames(pattern)) names.add(name);
+  };
+  const currentScope = () => scopeStack[scopeStack.length - 1];
+  const nearestFunctionScope = () => [...scopeStack].reverse().find(
+    ({ kind }) => kind === "function" || kind === "program" || kind === "static"
+  );
+  const pushFunctionScope = (node) => {
+    pushScope(node, "function");
+    if (node.type === "FunctionExpression" && node.id) declareIn(currentScope(), node.id);
+    for (const param of node.params ?? []) declareIn(currentScope(), param);
+  };
+  pushScope(program2, "program");
+  const visitor = new Visitor2({
+    BlockStatement(node) {
+      pushScope(node, "block");
+    },
+    "BlockStatement:exit"() {
+      scopeStack.pop();
+    },
+    FunctionDeclaration(node) {
+      declareIn(currentScope(), node.id);
+      pushFunctionScope(node);
+    },
+    "FunctionDeclaration:exit"() {
+      scopeStack.pop();
+    },
+    FunctionExpression: pushFunctionScope,
+    "FunctionExpression:exit"() {
+      scopeStack.pop();
+    },
+    ArrowFunctionExpression: pushFunctionScope,
+    "ArrowFunctionExpression:exit"() {
+      scopeStack.pop();
+    },
+    ClassDeclaration(node) {
+      declareIn(currentScope(), node.id);
+      pushScope(node, "class");
+      declareIn(currentScope(), node.id);
+    },
+    "ClassDeclaration:exit"() {
+      scopeStack.pop();
+    },
+    ClassExpression(node) {
+      pushScope(node, "class");
+      if (node.id) declareIn(currentScope(), node.id);
+    },
+    "ClassExpression:exit"() {
+      scopeStack.pop();
+    },
+    ForStatement(node) {
+      pushScope(node, "loop");
+    },
+    "ForStatement:exit"() {
+      scopeStack.pop();
+    },
+    ForInStatement(node) {
+      pushScope(node, "loop");
+    },
+    "ForInStatement:exit"() {
+      scopeStack.pop();
+    },
+    ForOfStatement(node) {
+      pushScope(node, "loop");
+    },
+    "ForOfStatement:exit"() {
+      scopeStack.pop();
+    },
+    SwitchStatement(node) {
+      pushScope(node, "switch");
+    },
+    "SwitchStatement:exit"() {
+      scopeStack.pop();
+    },
+    StaticBlock(node) {
+      pushScope(node, "static");
+    },
+    "StaticBlock:exit"() {
+      scopeStack.pop();
+    },
+    CatchClause(node) {
+      pushScope(node, "catch");
+      if (node.param) declareIn(currentScope(), node.param);
+    },
+    "CatchClause:exit"() {
+      scopeStack.pop();
+    },
+    VariableDeclaration(node) {
+      const target = node.kind === "var" ? nearestFunctionScope() : currentScope();
+      for (const declaration of node.declarations ?? []) declareIn(target, declaration.id);
+    }
+  });
+  visitor.visit(program2);
+  scopeStack.pop();
+  return bindings;
+}
 var STATIC_FEEDBACK_METHODS = {
   message: ["open", "success", "error", "info", "warning", "warn", "loading"],
   notification: ["open", "success", "error", "info", "warning", "warn"],
@@ -17580,6 +17726,17 @@ function normalizeAntdAliases(antdAliases) {
 function matchesAntdAlias(source, antdAliases) {
   return antdAliases.some((antdAlias) => source === antdAlias || source.startsWith(`${antdAlias}/`));
 }
+function getComponentFromSubpath(source, antdAliases, componentBySubpath) {
+  const matchedAlias = [...antdAliases].sort((a, b) => b.length - a.length).find((antdAlias) => source.startsWith(`${antdAlias}/`));
+  const parts = source.slice(matchedAlias.length + 1).split("/");
+  const componentParts = parts[0] === "es" || parts[0] === "lib" ? parts.slice(1) : parts;
+  if (componentParts.includes("style") || componentParts.includes("locale")) return void 0;
+  for (let i = componentParts.length - 1; i >= 0; i--) {
+    const componentName = componentBySubpath.get(normalizeComponentKey(componentParts[i]));
+    if (componentName) return componentName;
+  }
+  return void 0;
+}
 function isLocalePath(source, antdAliases) {
   return antdAliases.some(
     (alias) => source.startsWith(`${alias}/locale/`) || source.startsWith(`${alias}/es/locale/`) || source.startsWith(`${alias}/lib/locale/`)
@@ -17591,6 +17748,54 @@ function isNonModuleSource(source) {
   if (!match) return false;
   return !MODULE_EXTENSIONS.has(match[1].toLowerCase());
 }
+function collectAntdImports(program2, antdAliases, componentBySubpath) {
+  const importedComponents = /* @__PURE__ */ new Set();
+  const antdImportLocals = /* @__PURE__ */ new Map();
+  const antdRootImportLocals = /* @__PURE__ */ new Set();
+  const performanceImports = [];
+  const visitor = new Visitor2({
+    ImportDeclaration(node) {
+      const source = node.source.value;
+      if (!matchesAntdAlias(source, antdAliases) || node.importKind === "type") return;
+      const isRootImport = antdAliases.includes(source);
+      for (const spec of node.specifiers) {
+        if (spec.type === "ImportSpecifier" && spec.importKind !== "type") {
+          const name = spec.imported?.name || spec.local?.name;
+          const localName = spec.local?.name || name;
+          if (name) importedComponents.add(name);
+          if (name && localName) antdImportLocals.set(localName, name);
+        }
+        if (spec.type === "ImportNamespaceSpecifier" && isRootImport) {
+          antdRootImportLocals.add(spec.local?.name ?? "");
+        }
+        if (spec.type === "ImportDefaultSpecifier") {
+          const localName = spec.local?.name;
+          if (localName && isRootImport) {
+            antdRootImportLocals.add(localName);
+          } else if (localName) {
+            const componentName = getComponentFromSubpath(source, antdAliases, componentBySubpath);
+            if (componentName) {
+              importedComponents.add(componentName);
+              antdImportLocals.set(localName, componentName);
+            }
+          }
+        }
+        const isNamespace = spec.type === "ImportNamespaceSpecifier";
+        const isDefault = spec.type === "ImportDefaultSpecifier";
+        if ((isNamespace || isDefault) && !isLocalePath(source, antdAliases) && !isNonModuleSource(source)) {
+          performanceImports.push({
+            node,
+            source,
+            localName: spec.local?.name ?? "",
+            kind: isNamespace ? "namespace" : "default"
+          });
+        }
+      }
+    }
+  });
+  visitor.visit(program2);
+  return { importedComponents, antdImportLocals, antdRootImportLocals, performanceImports };
+}
 function mayContainAntdAlias(content, antdAliases) {
   return antdAliases.some((antdAlias) => content.includes(antdAlias));
 }
@@ -17656,7 +17861,7 @@ function collectGitFiles(targetPath, mode, diff) {
   const args = mode === "staged" ? ["diff", "--name-only", "--cached", "--diff-filter=ACMR", "--", pathspec] : ["diff", "--name-only", "--diff-filter=ACMR", resolveDiffBase(repoRoot, diff), "--", pathspec];
   return execGit(repoRoot, args).split("\n").map((file2) => file2.trim()).filter(Boolean).filter((file2) => isLintableSource(join5(repoRoot, file2), file2)).map((file2) => join5(repoRoot, file2));
 }
-function lintFile(filePath, deprecatedMap, antdAliases, antdMajor, only) {
+function lintFile(filePath, deprecatedMap, deprecatedComponents, componentBySubpath, antdAliases, antdMajor, only) {
   let content;
   try {
     content = readFileSync7(filePath, "utf-8");
@@ -17683,8 +17888,12 @@ function lintFile(filePath, deprecatedMap, antdAliases, antdMajor, only) {
     };
   }
   const issues = [];
-  const importedComponents = /* @__PURE__ */ new Set();
-  const antdImportLocals = /* @__PURE__ */ new Map();
+  const {
+    importedComponents,
+    antdImportLocals,
+    antdRootImportLocals,
+    performanceImports
+  } = collectAntdImports(result.program, antdAliases, componentBySubpath);
   const offsetToLine = createLineMapper(content);
   const enableV5UsageRules = antdMajor >= 5;
   const lineOf = (node) => {
@@ -17696,48 +17905,74 @@ function lintFile(filePath, deprecatedMap, antdAliases, antdMajor, only) {
   };
   const jsxAncestorStack = [];
   const isInsideComponent = (name) => jsxAncestorStack.includes(name);
-  const pendingPerformanceIssues = [];
-  const namespaceMemberUsage = /* @__PURE__ */ new Map();
-  const scopeStack = [/* @__PURE__ */ new Set()];
-  const declarePattern = (pattern) => {
-    const currentScope = scopeStack[scopeStack.length - 1];
-    for (const name of collectPatternNames(pattern)) {
-      currentScope.add(name);
-    }
-  };
+  const pendingPerformanceIssues = !only || only === "performance" ? performanceImports.map(({ node, ...item }) => ({ line: lineOf(node), ...item })) : [];
+  const namespaceMemberUsage = new Map(
+    pendingPerformanceIssues.map((item) => [item.localName, /* @__PURE__ */ new Set()])
+  );
+  const scopeBindings = collectScopeBindings(result.program);
+  const scopeStack = [scopeBindings.get(result.program) ?? /* @__PURE__ */ new Set()];
+  const pushScope = (node) => scopeStack.push(scopeBindings.get(node) ?? /* @__PURE__ */ new Set());
   const isShadowed = (name) => scopeStack.some((scope) => scope.has(name));
-  const pushFunctionScope = (node) => {
-    scopeStack.push(/* @__PURE__ */ new Set());
-    for (const param of node.params ?? []) declarePattern(param);
+  const resolveCanonicalComponent = (compName) => {
+    const [localRoot, ...members] = compName.split(".");
+    if (!localRoot || isShadowed(localRoot)) return null;
+    const importedRoot = antdImportLocals.get(localRoot);
+    if (importedRoot) {
+      return { root: importedRoot, full: [importedRoot, ...members].join(".") };
+    }
+    if (antdRootImportLocals.has(localRoot) && members.length > 0) {
+      return { root: members[0], full: members.join(".") };
+    }
+    return null;
   };
   const visitor = new Visitor2({
-    BlockStatement() {
-      scopeStack.push(/* @__PURE__ */ new Set());
-    },
+    BlockStatement: pushScope,
     "BlockStatement:exit"() {
       scopeStack.pop();
     },
-    FunctionDeclaration: pushFunctionScope,
+    FunctionDeclaration: pushScope,
     "FunctionDeclaration:exit"() {
       scopeStack.pop();
     },
-    FunctionExpression: pushFunctionScope,
+    FunctionExpression: pushScope,
     "FunctionExpression:exit"() {
       scopeStack.pop();
     },
-    ArrowFunctionExpression: pushFunctionScope,
+    ArrowFunctionExpression: pushScope,
     "ArrowFunctionExpression:exit"() {
       scopeStack.pop();
     },
-    CatchClause(node) {
-      scopeStack.push(/* @__PURE__ */ new Set());
-      if (node.param) declarePattern(node.param);
+    ClassDeclaration: pushScope,
+    "ClassDeclaration:exit"() {
+      scopeStack.pop();
     },
-    "CatchClause:exit"() {
+    ClassExpression: pushScope,
+    "ClassExpression:exit"() {
+      scopeStack.pop();
+    },
+    ForStatement: pushScope,
+    "ForStatement:exit"() {
+      scopeStack.pop();
+    },
+    ForInStatement: pushScope,
+    "ForInStatement:exit"() {
+      scopeStack.pop();
+    },
+    ForOfStatement: pushScope,
+    "ForOfStatement:exit"() {
       scopeStack.pop();
     },
-    VariableDeclarator(node) {
-      declarePattern(node.id);
+    SwitchStatement: pushScope,
+    "SwitchStatement:exit"() {
+      scopeStack.pop();
+    },
+    StaticBlock: pushScope,
+    "StaticBlock:exit"() {
+      scopeStack.pop();
+    },
+    CatchClause: pushScope,
+    "CatchClause:exit"() {
+      scopeStack.pop();
     },
     JSXElement(node) {
       const elName = getJSXElementName(node.openingElement?.name);
@@ -17746,34 +17981,6 @@ function lintFile(filePath, deprecatedMap, antdAliases, antdMajor, only) {
     "JSXElement:exit"() {
       jsxAncestorStack.pop();
     },
-    ImportDeclaration(node) {
-      const source = node.source.value;
-      if (!matchesAntdAlias(source, antdAliases)) 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;
-          const localName = spec.local?.name || name;
-          if (name) importedComponents.add(name);
-          if (name && localName) antdImportLocals.set(localName, name);
-        }
-        if (!only || only === "performance") {
-          const isNamespace = spec.type === "ImportNamespaceSpecifier";
-          const isDefault = spec.type === "ImportDefaultSpecifier";
-          if ((isNamespace || isDefault) && !isLocalePath(source, antdAliases) && !isNonModuleSource(source)) {
-            const localName = spec.local?.name ?? "";
-            pendingPerformanceIssues.push({
-              line: lineOf(node),
-              source,
-              localName,
-              kind: isNamespace ? "namespace" : "default"
-            });
-            namespaceMemberUsage.set(localName, /* @__PURE__ */ new Set());
-          }
-        }
-      }
-    },
     CallExpression(node) {
       if (only && only !== "usage") return;
       if (!enableV5UsageRules) return;
@@ -17800,25 +18007,29 @@ function lintFile(filePath, deprecatedMap, antdAliases, antdMajor, only) {
         }
       }
       if (!only || only === "deprecated") {
-        if (compName === "BackTop" && importedComponents.has("BackTop")) {
+        const canonicalComponent = resolveCanonicalComponent(compName);
+        if (canonicalComponent?.full === "BackTop") {
           report("deprecated", "warning", line, "`BackTop` is deprecated, use `FloatButton.BackTop` instead");
         }
-        if (compName === "Button.Group" && importedComponents.has("Button")) {
+        if (canonicalComponent?.full === "Button.Group") {
           report("deprecated", "warning", line, "`Button.Group` is deprecated, use `Space.Compact` instead");
         }
-        if (compName === "Input.Group" && importedComponents.has("Input")) {
+        if (canonicalComponent?.full === "Input.Group") {
           report("deprecated", "warning", line, "`Input.Group` is deprecated, use `Space.Compact` instead");
         }
-        const baseName = compName.includes(".") ? compName.split(".")[0] : compName;
-        if (importedComponents.has(baseName) || importedComponents.has(compName)) {
-          const deprecations = deprecatedMap.get(compName);
+        if (canonicalComponent) {
+          const componentNotice = deprecatedComponents.get(canonicalComponent.root);
+          if (componentNotice) {
+            report("deprecated", "warning", line, componentNotice);
+          }
+          const deprecations = deprecatedMap.get(canonicalComponent.full);
           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", lineOf(attr) || line, `${compName} ${dep.message}`);
+                report("deprecated", "warning", lineOf(attr) || line, `${canonicalComponent.full} ${dep.message}`);
               }
             }
           }
@@ -17953,6 +18164,10 @@ function registerLintCommand(program2) {
     const versionInfo = detectVersion(opts.version);
     const store = loadMetadataForVersion(versionInfo.version);
     const deprecatedMap = getDeprecatedProps(store);
+    const deprecatedComponents = getDeprecatedComponents(store, opts.lang);
+    const componentBySubpath = new Map(
+      store.components.map((component) => [normalizeComponentKey(component.name), component.name])
+    );
     const antdAliases = normalizeAntdAliases(cmdOpts.antdAlias);
     let files;
     try {
@@ -17963,7 +18178,7 @@ function registerLintCommand(program2) {
     const allIssues = [];
     const skippedFiles = [];
     for (const file2 of files) {
-      const result = lintFile(file2, deprecatedMap, antdAliases, parseInt(versionInfo.majorVersion.slice(1), 10), cmdOpts.only);
+      const result = lintFile(file2, deprecatedMap, deprecatedComponents, componentBySubpath, antdAliases, parseInt(versionInfo.majorVersion.slice(1), 10), cmdOpts.only);
       allIssues.push(...result.issues);
       if (result.skipped) skippedFiles.push(result.skipped);
     }
@@ -18876,32 +19091,6 @@ var V5_TO_V6_STEPS = [
 <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,
@@ -19551,7 +19740,7 @@ function collectAntdEnv(cwd, versionOverride) {
 function collectCliEnv() {
   let cliVersion;
   try {
-    cliVersion = "6.6.0";
+    cliVersion = "6.6.1";
   } catch (err) {
     console.error("Failed to get CLI version:", err);
     cliVersion = "unknown";
@@ -20030,11 +20219,15 @@ import { execFile, spawn } from "child_process";
 
 // src/utils/detect-pm.ts
 import { execFileSync as execFileSync4 } from "child_process";
+var PACKAGE_MANAGERS = ["npm", "yarn", "pnpm", "bun", "cnpm", "utoo"];
 var PM_RULES = [
   { pm: "utoo", keywords: [".utoo", "utoo/global"] },
   { pm: "cnpm", keywords: [".cnpm", "cnpm/global"] },
-  { pm: "yarn", keywords: ["yarn/global"] },
-  { pm: "pnpm", keywords: [".pnpm-global", "pnpm/global"] },
+  {
+    pm: "yarn",
+    keywords: ["yarn/global", "/.yarn/bin/", "/yarn/bin/", "/yarn/data/global/", "/yarn/config/global/"]
+  },
+  { pm: "pnpm", keywords: [".pnpm-global", "pnpm/global", "/pnpm/"] },
   { pm: "bun", keywords: [".bun", "bun/install/global"] }
 ];
 var UPGRADE_COMMANDS = {
@@ -20045,8 +20238,11 @@ var UPGRADE_COMMANDS = {
   cnpm: { cmd: "cnpm", args: ["install", "-g", "@ant-design/cli@latest"] },
   utoo: { cmd: "ut", args: ["install", "-g", "@ant-design/cli@latest"] }
 };
+function isPackageManager(value) {
+  return typeof value === "string" && PACKAGE_MANAGERS.includes(value);
+}
 function inferPackageManagerFromPath(binPath) {
-  const normalized = binPath.replace(/\\/g, "/");
+  const normalized = binPath.replace(/\\/g, "/").toLowerCase();
   for (const rule of PM_RULES) {
     for (const keyword of rule.keywords) {
       if (normalized.includes(keyword)) return rule.pm;
@@ -20054,7 +20250,15 @@ function inferPackageManagerFromPath(binPath) {
   }
   return "npm";
 }
-function detectPackageManager() {
+function isAntdCliPath(entryPath) {
+  const normalized = entryPath.replace(/\\/g, "/").toLowerCase();
+  const fileName = normalized.split("/").pop();
+  return fileName === "antd" || fileName === "antd.cmd" || fileName === "antd.exe" || normalized.endsWith("/@ant-design/cli/dist/index.js");
+}
+function findAntdBinaryPath(invocationPath = process.argv[1]) {
+  if (invocationPath && isAntdCliPath(invocationPath)) {
+    return invocationPath;
+  }
   const isWin = process.platform === "win32";
   try {
     const binPath = execFileSync4(isWin ? "where" : "which", ["antd"], {
@@ -20062,12 +20266,18 @@ function detectPackageManager() {
       timeout: 5e3
     }).trim();
     if (!binPath) return null;
-    const firstPath = binPath.split("\n")[0].trim();
-    return inferPackageManagerFromPath(firstPath);
+    return binPath.split(/\r?\n/)[0].trim() || null;
   } catch {
     return null;
   }
 }
+function detectPackageManager() {
+  const binPath = findAntdBinaryPath();
+  return binPath ? inferPackageManagerFromPath(binPath) : null;
+}
+
+// src/utils/update-check.ts
+import stringWidth3 from "string-width";
 
 // node_modules/conf/dist/source/index.js
 import { isDeepStrictEqual } from "util";
@@ -21745,26 +21955,29 @@ async function fetchLatestVersion() {
 }
 function printUpdateNotice(currentVersion, latestVersion) {
   const line = `  Update available: ${currentVersion} \u2192 ${latestVersion}  `;
+  const binPath = findAntdBinaryPath();
+  const packageManager = binPath ? inferPackageManagerFromPath(binPath) : "npm";
+  const upgrade = UPGRADE_COMMANDS[packageManager];
+  const running = binPath ? `  Running: ${binPath}  ` : null;
   const cmd = "  Run: antd upgrade  ";
-  const install = "  Or: npm i -g @ant-design/cli  ";
-  const width = Math.max(line.length, cmd.length, install.length);
-  const pad = (s) => s + " ".repeat(width - s.length);
+  const install = `  Or: ${upgrade.cmd} ${upgrade.args.join(" ")}  `;
+  const lines = [line, running, cmd, install].filter((item) => item !== null);
+  const width = Math.max(...lines.map((item) => stringWidth3(item)));
+  const pad = (s) => s + " ".repeat(width - stringWidth3(s));
   const bar = "\u2500".repeat(width);
   process.stderr.write(`
 \u256D${bar}\u256E
 `);
-  process.stderr.write(`\u2502${pad(line)}\u2502
-`);
-  process.stderr.write(`\u2502${pad(cmd)}\u2502
-`);
-  process.stderr.write(`\u2502${pad(install)}\u2502
+  for (const item of lines) {
+    process.stderr.write(`\u2502${pad(item)}\u2502
 `);
+  }
   process.stderr.write(`\u2570${bar}\u256F
 `);
 }
 async function checkForUpdate() {
   if (process.env.CI || process.env.NO_UPDATE_CHECK) return;
-  const currentVersion = "6.6.0";
+  const currentVersion = "6.6.1";
   if (!valid(currentVersion)) return;
   const now = Date.now();
   const cache = cacheStore.get("updateCache") ?? null;
@@ -21815,9 +22028,14 @@ function runUpgrade(cmd, args) {
   });
 }
 function registerUpgradeCommand(program2) {
-  program2.command("upgrade").description("Upgrade the CLI to the latest version").action(async () => {
+  program2.command("upgrade").description("Upgrade the CLI to the latest version").addOption(
+    new Option("--package-manager <manager>", "Package manager to use and remember for future upgrades").choices(PACKAGE_MANAGERS)
+  ).action(async (cmdOpts) => {
     const opts = program2.opts();
-    const currentVersion = "6.6.0";
+    const currentVersion = "6.6.1";
+    if (cmdOpts.packageManager) {
+      configStore.set("packageManager", cmdOpts.packageManager);
+    }
     let latestVersion;
     try {
       latestVersion = await fetchLatestVersion();
@@ -21872,7 +22090,11 @@ function registerUpgradeCommand(program2) {
       }
       return;
     }
-    const pm = detectPackageManager();
+    let pm = cmdOpts.packageManager;
+    if (!pm) {
+      const savedPackageManager = configStore.get("packageManager");
+      pm = isPackageManager(savedPackageManager) ? savedPackageManager : detectPackageManager() ?? void 0;
+    }
     if (!pm) {
       const err = createError(
         ErrorCodes.PM_NOT_FOUND,
@@ -36270,7 +36492,7 @@ function registerMcpCommand(program2) {
       const opts = program2.opts();
       const versionInfo = detectVersion(opts.version);
       const server = new Server(
-        { name: "antd", version: "6.6.0" },
+        { name: "antd", version: "6.6.1" },
         { capabilities: { tools: {}, prompts: {} } }
       );
       const handleTool = createToolHandler({
@@ -36949,7 +37171,7 @@ ${wordmarkLines.join("\n")}`;
 }
 
 // src/index.ts
-var CLI_VERSION = "6.6.0";
+var CLI_VERSION = "6.6.1";
 function createProgram() {
   const program2 = new Command();
   let displayedRootHelp = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ant-design/cli",
-  "version": "6.6.0",
+  "version": "6.6.1",
   "description": "CLI tool for querying antd knowledge and analyzing antd usage in projects",
   "type": "module",
   "bin": {
@@ -51,7 +51,7 @@
     "cfonts": "^3.3.1",
     "fast-glob": "^3.3.3",
     "fast-levenshtein": "^3.0.0",
-    "oxc-parser": "^0.138.0",
+    "oxc-parser": "^0.144.0",
     "semver": "^7.8.0",
     "string-width": "^8.2.1"
   },