bun-push 0.1.9

package/dist/cli.js

@@ -0,0 +1,1459 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
+
+// src/cli.ts
+import ora from "ora";
+import chalk3 from "chalk";
+
+// src/utils/workspace.ts
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join, resolve } from "path";
+
+// src/i18n/locales/zh.ts
+var zh_default = {
+  common: {
+    yes: "\u662F",
+    no: "\u5426",
+    skip: "\u8DF3\u8FC7",
+    cancel: "\u53D6\u6D88",
+    confirm: "\u786E\u8BA4",
+    error: "\u9519\u8BEF",
+    success: "\u6210\u529F"
+  },
+  package: {
+    selectPackage: "\u8BF7\u9009\u62E9\u8981\u53D1\u5E03\u7684\u5305",
+    selectedPackage: "\u5DF2\u9009\u62E9\u5305"
+  },
+  changelog: {
+    input: "\u8BF7\u8F93\u5165 changelog\uFF08\u5355\u884C\u8F93\u5165\uFF0C\u652F\u6301\u591A\u6B21\u8F93\u5165\uFF0C\u8F93\u5165\u7A7A\u884C\u7ED3\u675F\uFF09",
+    singleLineHint: "\u652F\u6301\u591A\u6B21\u5355\u884C\u8F93\u5165\uFF0C\u8F93\u5165\u7A7A\u884C\u7ED3\u675F\u3002\u5982\u679C\u8F93\u5165\u4E3A\u7A7A\uFF0C\u5C06\u4F7F\u7528\u9ED8\u8BA4\u7684\u7248\u672C\u5347\u7EA7\u8BB0\u5F55",
+    empty: "changelog \u4E0D\u80FD\u4E3A\u7A7A",
+    generate: "\u662F\u5426\u751F\u6210 CHANGELOG.md \u6587\u4EF6\uFF1F",
+    usingDefault: "\u4F7F\u7528\u9ED8\u8BA4 changelog\uFF1A\u7248\u672C\u5347\u7EA7\u8BB0\u5F55",
+    defaultContent: "\u5347\u7EA7\u7248\u672C\u53F7: {currentVersion} \u2192 {newVersion}"
+  },
+  version: {
+    selectType: "\u9009\u62E9\u7248\u672C\u7C7B\u578B",
+    currentVersion: "\u5F53\u524D\u7248\u672C",
+    finalVersion: "\u6700\u7EC8\u7248\u672C",
+    customVersion: "\u81EA\u5B9A\u4E49\u7248\u672C\u53F7",
+    customVersionDesc: "\u624B\u52A8\u8F93\u5165\u7248\u672C\u53F7",
+    inputVersion: "\u8BF7\u8F93\u5165\u7248\u672C\u53F7",
+    example: "\u793A\u4F8B",
+    versionEmpty: "\u7248\u672C\u53F7\u4E0D\u80FD\u4E3A\u7A7A",
+    patch: "\u8865\u4E01\u7248\u672C - \u4FEE\u590D bug",
+    minor: "\u6B21\u7248\u672C - \u65B0\u529F\u80FD\uFF0C\u5411\u540E\u517C\u5BB9",
+    major: "\u4E3B\u7248\u672C - \u7834\u574F\u6027\u53D8\u66F4",
+    invalid: "\u65E0\u6548\u7684\u7248\u672C\u53F7",
+    invalidWithVersion: "\u65E0\u6548\u7684\u7248\u672C\u53F7: {version}",
+    cannotGenerate: "\u65E0\u6CD5\u751F\u6210\u4E0B\u4E00\u4E2A\u7248\u672C\u53F7",
+    unsupportedType: "\u4E0D\u652F\u6301\u7684\u53D1\u5E03\u7C7B\u578B",
+    unsupportedTypeWithType: "\u4E0D\u652F\u6301\u7684\u53D1\u5E03\u7C7B\u578B: {type}",
+    versionFormat: "{current} -> {next}"
+  },
+  script: {
+    select: "\u8BF7\u9009\u62E9\u8981\u6267\u884C\u7684\u811A\u672C\uFF08\u901A\u5E38\u662F build\uFF09",
+    noScripts: "\u8BE5\u5305\u6CA1\u6709 scripts",
+    running: "\u6267\u884C\u811A\u672C",
+    success: "\u811A\u672C\u6267\u884C\u6210\u529F",
+    failed: "\u811A\u672C\u6267\u884C\u5931\u8D25",
+    notFound: "\u811A\u672C\u4E0D\u5B58\u5728",
+    notFoundWithName: '\u811A\u672C "{name}" \u4E0D\u5B58\u5728',
+    executionFailed: "\u811A\u672C\u6267\u884C\u5931\u8D25\uFF0C\u9000\u51FA\u7801: {exitCode}"
+  },
+  git: {
+    pushTag: "\u662F\u5426\u63A8\u9001 git tag\uFF1F",
+    createTagFailed: "\u521B\u5EFA git tag \u5931\u8D25\uFF0C\u9000\u51FA\u7801: {exitCode}",
+    pushTagFailed: "\u63A8\u9001 git tag \u5931\u8D25\uFF0C\u9000\u51FA\u7801: {exitCode}"
+  },
+  registry: {
+    input: "\u8BF7\u8F93\u5165 npm registry \u5730\u5740",
+    empty: "registry \u5730\u5740\u4E0D\u80FD\u4E3A\u7A7A",
+    invalid: "\u8BF7\u8F93\u5165\u6709\u6548\u7684 URL"
+  },
+  publish: {
+    preview: "\u53D1\u5E03\u914D\u7F6E\u9884\u89C8",
+    packageName: "\u5305\u540D",
+    currentVersion: "\u5F53\u524D\u7248\u672C",
+    newVersion: "\u65B0\u7248\u672C",
+    tag: "Tag",
+    changelog: "Changelog",
+    registry: "Registry",
+    pushTag: "\u63A8\u9001 Tag",
+    generateChangelog: "\u751F\u6210 Changelog",
+    script: "\u6267\u884C\u811A\u672C",
+    confirm: "\u786E\u8BA4\u53D1\u5E03\uFF1F",
+    publishing: "\u6B63\u5728\u53D1\u5E03\u5230 npm...",
+    success: "\u53D1\u5E03\u6210\u529F\uFF01",
+    failed: "\u53D1\u5E03\u5931\u8D25",
+    cancelled: "\u5DF2\u53D6\u6D88\u53D1\u5E03",
+    error: "\u53D1\u5E03\u8FC7\u7A0B\u4E2D\u51FA\u73B0\u9519\u8BEF",
+    generalError: "\u9519\u8BEF",
+    npmPublishFailed: "npm \u53D1\u5E03\u5931\u8D25\uFF0C\u9000\u51FA\u7801: {exitCode}",
+    npmNotLoggedIn: "\u672A\u767B\u5F55\u5230 npm registry: {registry}\uFF0C\u8BF7\u5148\u8FD0\u884C 'npm login --registry {registry}' \u767B\u5F55",
+    npmAuthCheckFailed: "\u68C0\u67E5 npm \u767B\u5F55\u72B6\u6001\u5931\u8D25 (registry: {registry}): {error}",
+    needOtp: "\u662F\u5426\u9700\u8981\u8F93\u5165 npm \u53D1\u5E03\u7684\u4E00\u6B21\u6027\u4EE3\u7801\uFF08OTP\uFF09\uFF1F",
+    inputOtp: "\u8BF7\u8F93\u5165\u4E00\u6B21\u6027\u4EE3\u7801\uFF08OTP\uFF09",
+    otpEmpty: "\u4E00\u6B21\u6027\u4EE3\u7801\u4E0D\u80FD\u4E3A\u7A7A",
+    otpInvalid: "\u4E00\u6B21\u6027\u4EE3\u7801\u5FC5\u987B\u662F 6 \u4F4D\u6570\u5B57",
+    otp: "\u4E00\u6B21\u6027\u4EE3\u7801\uFF08OTP\uFF09",
+    rollingBack: "\u53D1\u5E03\u5931\u8D25\uFF0C\u6B63\u5728\u56DE\u6EDA\u4FEE\u6539...",
+    rollbackComplete: "\u56DE\u6EDA\u5B8C\u6210",
+    rollbackFailed: "\u56DE\u6EDA\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6062\u590D\u7248\u672C\u53F7\u548C changelog:"
+  },
+  success: {
+    title: "\u53D1\u5E03\u6210\u529F\uFF01",
+    packageName: "\u5305\u540D",
+    version: "\u7248\u672C",
+    registry: "Registry",
+    thanks: "\u611F\u8C22\u4F7F\u7528 bun-push\uFF01"
+  },
+  changelogTypes: {
+    added: "\u65B0\u589E",
+    changed: "\u53D8\u66F4",
+    deprecated: "\u5E9F\u5F03",
+    removed: "\u79FB\u9664",
+    fixed: "\u4FEE\u590D",
+    security: "\u5B89\u5168"
+  },
+  workspace: {
+    packageJsonNotFound: "\u672A\u627E\u5230 package.json \u6587\u4EF6",
+    workspacesConfigInvalid: "workspaces \u914D\u7F6E\u65E0\u6548",
+    packageNotFound: "\u672A\u627E\u5230\u8981\u53D1\u5E03\u7684\u5305",
+    packageNotFoundByPath: "\u672A\u627E\u5230\u8DEF\u5F84\u4E3A {path} \u7684\u5305",
+    monorepoRequiresPath: "monorepo \u6A21\u5F0F\u4E0B\u5FC5\u987B\u6307\u5B9A packagePath \u6216\u4F7F\u7528 CLI \u6A21\u5F0F"
+  }
+};
+
+// src/i18n/locales/en.ts
+var en_default = {
+  common: {
+    yes: "Yes",
+    no: "No",
+    skip: "Skip",
+    cancel: "Cancel",
+    confirm: "Confirm",
+    error: "Error",
+    success: "Success"
+  },
+  package: {
+    selectPackage: "Select package to publish",
+    selectedPackage: "Selected package"
+  },
+  changelog: {
+    input: "Enter changelog (single line input, supports multiple inputs, press Enter to finish)",
+    singleLineHint: "Supports multiple single-line inputs, press Enter to finish. If input is empty, default version upgrade record will be used",
+    empty: "changelog cannot be empty",
+    generate: "Generate CHANGELOG.md file?",
+    usingDefault: "Using default changelog: version upgrade record",
+    defaultContent: "Upgrade version: {currentVersion} \u2192 {newVersion}"
+  },
+  version: {
+    selectType: "Select version type",
+    currentVersion: "Current version",
+    finalVersion: "Final version",
+    customVersion: "Custom version",
+    customVersionDesc: "Enter version manually",
+    inputVersion: "Enter version number",
+    example: "Example",
+    versionEmpty: "Version cannot be empty",
+    patch: "Patch version - Bug fixes",
+    minor: "Minor version - New features, backward compatible",
+    major: "Major version - Breaking changes",
+    invalid: "Invalid version number",
+    invalidWithVersion: "Invalid version number: {version}",
+    cannotGenerate: "Cannot generate next version",
+    unsupportedType: "Unsupported release type",
+    unsupportedTypeWithType: "Unsupported release type: {type}",
+    versionFormat: "{current} -> {next}"
+  },
+  script: {
+    select: "Select script to run (usually build)",
+    noScripts: "This package has no scripts",
+    running: "Running script",
+    success: "Script executed successfully",
+    failed: "Script execution failed",
+    notFound: "Script not found",
+    notFoundWithName: 'Script "{name}" not found',
+    executionFailed: "Script execution failed, exit code: {exitCode}"
+  },
+  git: {
+    pushTag: "Push git tag?",
+    createTagFailed: "Failed to create git tag, exit code: {exitCode}",
+    pushTagFailed: "Failed to push git tag, exit code: {exitCode}"
+  },
+  registry: {
+    input: "Enter npm registry address",
+    empty: "Registry address cannot be empty",
+    invalid: "Please enter a valid URL"
+  },
+  publish: {
+    preview: "Publish configuration preview",
+    packageName: "Package name",
+    currentVersion: "Current version",
+    newVersion: "New version",
+    tag: "Tag",
+    changelog: "Changelog",
+    registry: "Registry",
+    pushTag: "Push Tag",
+    generateChangelog: "Generate Changelog",
+    script: "Script",
+    confirm: "Confirm publish?",
+    publishing: "Publishing to npm...",
+    success: "Published successfully!",
+    failed: "Publish failed",
+    cancelled: "Publish cancelled",
+    error: "Error during publish",
+    generalError: "Error",
+    npmPublishFailed: "npm publish failed, exit code: {exitCode}",
+    npmNotLoggedIn: "Not logged in to npm registry: {registry}, please run 'npm login --registry {registry}' first",
+    npmAuthCheckFailed: "Failed to check npm login status (registry: {registry}): {error}",
+    needOtp: "Do you need to enter npm publish one-time code (OTP)?",
+    inputOtp: "Enter one-time code (OTP)",
+    otpEmpty: "One-time code cannot be empty",
+    otpInvalid: "One-time code must be 6 digits",
+    otp: "One-time code (OTP)",
+    rollingBack: "Publish failed, rolling back changes...",
+    rollbackComplete: "Rollback completed",
+    rollbackFailed: "Rollback failed, please manually restore version and changelog:"
+  },
+  success: {
+    title: "Published successfully!",
+    packageName: "Package name",
+    version: "Version",
+    registry: "Registry",
+    thanks: "Thanks for using bun-push!"
+  },
+  changelogTypes: {
+    added: "Added",
+    changed: "Changed",
+    deprecated: "Deprecated",
+    removed: "Removed",
+    fixed: "Fixed",
+    security: "Security"
+  },
+  workspace: {
+    packageJsonNotFound: "package.json file not found",
+    workspacesConfigInvalid: "workspaces configuration is invalid",
+    packageNotFound: "Package not found",
+    packageNotFoundByPath: "Package not found at path: {path}",
+    monorepoRequiresPath: "In monorepo mode, packagePath must be specified or use CLI mode"
+  }
+};
+
+// src/i18n/locales/ja.ts
+var ja_default = {
+  common: {
+    yes: "\u306F\u3044",
+    no: "\u3044\u3044\u3048",
+    skip: "\u30B9\u30AD\u30C3\u30D7",
+    cancel: "\u30AD\u30E3\u30F3\u30BB\u30EB",
+    confirm: "\u78BA\u8A8D",
+    error: "\u30A8\u30E9\u30FC",
+    success: "\u6210\u529F"
+  },
+  package: {
+    selectPackage: "\u516C\u958B\u3059\u308B\u30D1\u30C3\u30B1\u30FC\u30B8\u3092\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044",
+    selectedPackage: "\u9078\u629E\u3055\u308C\u305F\u30D1\u30C3\u30B1\u30FC\u30B8"
+  },
+  changelog: {
+    input: "changelog\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044\uFF081\u884C\u5165\u529B\u3001\u8907\u6570\u56DE\u5165\u529B\u5BFE\u5FDC\u3001Enter\u30AD\u30FC\u3067\u7D42\u4E86\uFF09",
+    singleLineHint: "\u8907\u6570\u56DE\u306E1\u884C\u5165\u529B\u3092\u30B5\u30DD\u30FC\u30C8\u3001Enter\u30AD\u30FC\u3067\u7D42\u4E86\u3002\u5165\u529B\u304C\u7A7A\u306E\u5834\u5408\u3001\u30C7\u30D5\u30A9\u30EB\u30C8\u306E\u30D0\u30FC\u30B8\u30E7\u30F3\u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9\u8A18\u9332\u304C\u4F7F\u7528\u3055\u308C\u307E\u3059",
+    empty: "changelog\u306F\u7A7A\u306B\u3067\u304D\u307E\u305B\u3093",
+    generate: "CHANGELOG.md\u30D5\u30A1\u30A4\u30EB\u3092\u751F\u6210\u3057\u307E\u3059\u304B\uFF1F",
+    usingDefault: "\u30C7\u30D5\u30A9\u30EB\u30C8\u306Echangelog\u3092\u4F7F\u7528\uFF1A\u30D0\u30FC\u30B8\u30E7\u30F3\u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9\u8A18\u9332",
+    defaultContent: "\u30D0\u30FC\u30B8\u30E7\u30F3\u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9: {currentVersion} \u2192 {newVersion}"
+  },
+  version: {
+    selectType: "\u30D0\u30FC\u30B8\u30E7\u30F3\u30BF\u30A4\u30D7\u3092\u9078\u629E",
+    currentVersion: "\u73FE\u5728\u306E\u30D0\u30FC\u30B8\u30E7\u30F3",
+    finalVersion: "\u6700\u7D42\u30D0\u30FC\u30B8\u30E7\u30F3",
+    customVersion: "\u30AB\u30B9\u30BF\u30E0\u30D0\u30FC\u30B8\u30E7\u30F3",
+    customVersionDesc: "\u30D0\u30FC\u30B8\u30E7\u30F3\u3092\u624B\u52D5\u3067\u5165\u529B",
+    inputVersion: "\u30D0\u30FC\u30B8\u30E7\u30F3\u756A\u53F7\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    example: "\u4F8B",
+    versionEmpty: "\u30D0\u30FC\u30B8\u30E7\u30F3\u306F\u7A7A\u306B\u3067\u304D\u307E\u305B\u3093",
+    patch: "\u30D1\u30C3\u30C1\u30D0\u30FC\u30B8\u30E7\u30F3 - \u30D0\u30B0\u4FEE\u6B63",
+    minor: "\u30DE\u30A4\u30CA\u30FC\u30D0\u30FC\u30B8\u30E7\u30F3 - \u65B0\u6A5F\u80FD\u3001\u5F8C\u65B9\u4E92\u63DB",
+    major: "\u30E1\u30B8\u30E3\u30FC\u30D0\u30FC\u30B8\u30E7\u30F3 - \u7834\u58CA\u7684\u5909\u66F4",
+    invalid: "\u7121\u52B9\u306A\u30D0\u30FC\u30B8\u30E7\u30F3\u756A\u53F7",
+    invalidWithVersion: "\u7121\u52B9\u306A\u30D0\u30FC\u30B8\u30E7\u30F3\u756A\u53F7: {version}",
+    cannotGenerate: "\u6B21\u306E\u30D0\u30FC\u30B8\u30E7\u30F3\u3092\u751F\u6210\u3067\u304D\u307E\u305B\u3093",
+    unsupportedType: "\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u306A\u3044\u30EA\u30EA\u30FC\u30B9\u30BF\u30A4\u30D7",
+    unsupportedTypeWithType: "\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u306A\u3044\u30EA\u30EA\u30FC\u30B9\u30BF\u30A4\u30D7: {type}",
+    versionFormat: "{current} -> {next}"
+  },
+  script: {
+    select: "\u5B9F\u884C\u3059\u308B\u30B9\u30AF\u30EA\u30D7\u30C8\u3092\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u901A\u5E38\u306Fbuild\uFF09",
+    noScripts: "\u3053\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u306B\u306F\u30B9\u30AF\u30EA\u30D7\u30C8\u304C\u3042\u308A\u307E\u305B\u3093",
+    running: "\u30B9\u30AF\u30EA\u30D7\u30C8\u3092\u5B9F\u884C\u4E2D",
+    success: "\u30B9\u30AF\u30EA\u30D7\u30C8\u306E\u5B9F\u884C\u306B\u6210\u529F\u3057\u307E\u3057\u305F",
+    failed: "\u30B9\u30AF\u30EA\u30D7\u30C8\u306E\u5B9F\u884C\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+    notFound: "\u30B9\u30AF\u30EA\u30D7\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+    notFoundWithName: '\u30B9\u30AF\u30EA\u30D7\u30C8 "{name}" \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093',
+    executionFailed: "\u30B9\u30AF\u30EA\u30D7\u30C8\u306E\u5B9F\u884C\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3001\u7D42\u4E86\u30B3\u30FC\u30C9: {exitCode}"
+  },
+  git: {
+    pushTag: "git tag\u3092\u30D7\u30C3\u30B7\u30E5\u3057\u307E\u3059\u304B\uFF1F",
+    createTagFailed: "git tag\u306E\u4F5C\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3001\u7D42\u4E86\u30B3\u30FC\u30C9: {exitCode}",
+    pushTagFailed: "git tag\u306E\u30D7\u30C3\u30B7\u30E5\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3001\u7D42\u4E86\u30B3\u30FC\u30C9: {exitCode}"
+  },
+  registry: {
+    input: "npm registry\u30A2\u30C9\u30EC\u30B9\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    empty: "registry\u30A2\u30C9\u30EC\u30B9\u306F\u7A7A\u306B\u3067\u304D\u307E\u305B\u3093",
+    invalid: "\u6709\u52B9\u306AURL\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044"
+  },
+  publish: {
+    preview: "\u516C\u958B\u8A2D\u5B9A\u30D7\u30EC\u30D3\u30E5\u30FC",
+    packageName: "\u30D1\u30C3\u30B1\u30FC\u30B8\u540D",
+    currentVersion: "\u73FE\u5728\u306E\u30D0\u30FC\u30B8\u30E7\u30F3",
+    newVersion: "\u65B0\u3057\u3044\u30D0\u30FC\u30B8\u30E7\u30F3",
+    tag: "Tag",
+    changelog: "Changelog",
+    registry: "Registry",
+    pushTag: "Tag\u3092\u30D7\u30C3\u30B7\u30E5",
+    generateChangelog: "Changelog\u3092\u751F\u6210",
+    script: "\u30B9\u30AF\u30EA\u30D7\u30C8",
+    confirm: "\u516C\u958B\u3092\u78BA\u8A8D\u3057\u307E\u3059\u304B\uFF1F",
+    publishing: "npm\u306B\u516C\u958B\u4E2D...",
+    success: "\u516C\u958B\u306B\u6210\u529F\u3057\u307E\u3057\u305F\uFF01",
+    failed: "\u516C\u958B\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+    cancelled: "\u516C\u958B\u304C\u30AD\u30E3\u30F3\u30BB\u30EB\u3055\u308C\u307E\u3057\u305F",
+    error: "\u516C\u958B\u4E2D\u306B\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F",
+    generalError: "\u30A8\u30E9\u30FC",
+    npmPublishFailed: "npm\u516C\u958B\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3001\u7D42\u4E86\u30B3\u30FC\u30C9: {exitCode}",
+    npmNotLoggedIn: "npm registry \u306B\u30ED\u30B0\u30A4\u30F3\u3057\u3066\u3044\u307E\u305B\u3093: {registry}\uFF0C\u5148\u306B 'npm login --registry {registry}' \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044",
+    npmAuthCheckFailed: "npm \u30ED\u30B0\u30A4\u30F3\u72B6\u614B\u306E\u78BA\u8A8D\u306B\u5931\u6557\u3057\u307E\u3057\u305F (registry: {registry}): {error}",
+    needOtp: "npm\u516C\u958B\u306E\u30EF\u30F3\u30BF\u30A4\u30E0\u30B3\u30FC\u30C9\uFF08OTP\uFF09\u3092\u5165\u529B\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u304B\uFF1F",
+    inputOtp: "\u30EF\u30F3\u30BF\u30A4\u30E0\u30B3\u30FC\u30C9\uFF08OTP\uFF09\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    otpEmpty: "\u30EF\u30F3\u30BF\u30A4\u30E0\u30B3\u30FC\u30C9\u306F\u7A7A\u306B\u3067\u304D\u307E\u305B\u3093",
+    otpInvalid: "\u30EF\u30F3\u30BF\u30A4\u30E0\u30B3\u30FC\u30C9\u306F6\u6841\u306E\u6570\u5B57\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+    otp: "\u30EF\u30F3\u30BF\u30A4\u30E0\u30B3\u30FC\u30C9\uFF08OTP\uFF09",
+    rollingBack: "\u516C\u958B\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3001\u5909\u66F4\u3092\u30ED\u30FC\u30EB\u30D0\u30C3\u30AF\u4E2D...",
+    rollbackComplete: "\u30ED\u30FC\u30EB\u30D0\u30C3\u30AF\u304C\u5B8C\u4E86\u3057\u307E\u3057\u305F",
+    rollbackFailed: "\u30ED\u30FC\u30EB\u30D0\u30C3\u30AF\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3001\u30D0\u30FC\u30B8\u30E7\u30F3\u3068changelog\u3092\u624B\u52D5\u3067\u5FA9\u5143\u3057\u3066\u304F\u3060\u3055\u3044:"
+  },
+  success: {
+    title: "\u516C\u958B\u306B\u6210\u529F\u3057\u307E\u3057\u305F\uFF01",
+    packageName: "\u30D1\u30C3\u30B1\u30FC\u30B8\u540D",
+    version: "\u30D0\u30FC\u30B8\u30E7\u30F3",
+    registry: "Registry",
+    thanks: "bun-push\u3092\u3054\u5229\u7528\u3044\u305F\u3060\u304D\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\uFF01"
+  },
+  changelogTypes: {
+    added: "\u8FFD\u52A0",
+    changed: "\u5909\u66F4",
+    deprecated: "\u975E\u63A8\u5968",
+    removed: "\u524A\u9664",
+    fixed: "\u4FEE\u6B63",
+    security: "\u30BB\u30AD\u30E5\u30EA\u30C6\u30A3"
+  },
+  workspace: {
+    packageJsonNotFound: "package.json\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+    workspacesConfigInvalid: "workspaces\u8A2D\u5B9A\u304C\u7121\u52B9\u3067\u3059",
+    packageNotFound: "\u30D1\u30C3\u30B1\u30FC\u30B8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+    packageNotFoundByPath: "\u30D1\u30B9 {path} \u306B\u30D1\u30C3\u30B1\u30FC\u30B8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+    monorepoRequiresPath: "monorepo\u30E2\u30FC\u30C9\u3067\u306F\u3001packagePath\u3092\u6307\u5B9A\u3059\u308B\u304BCLI\u30E2\u30FC\u30C9\u3092\u4F7F\u7528\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059"
+  }
+};
+
+// src/i18n/locales/ko.ts
+var ko_default = {
+  common: {
+    yes: "\uC608",
+    no: "\uC544\uB2C8\uC624",
+    skip: "\uAC74\uB108\uB6F0\uAE30",
+    cancel: "\uCDE8\uC18C",
+    confirm: "\uD655\uC778",
+    error: "\uC624\uB958",
+    success: "\uC131\uACF5"
+  },
+  package: {
+    selectPackage: "\uAC8C\uC2DC\uD560 \uD328\uD0A4\uC9C0\uB97C \uC120\uD0DD\uD558\uC138\uC694",
+    selectedPackage: "\uC120\uD0DD\uB41C \uD328\uD0A4\uC9C0"
+  },
+  changelog: {
+    input: "changelog\uB97C \uC785\uB825\uD558\uC138\uC694 (\uD55C \uC904 \uC785\uB825, \uC5EC\uB7EC \uBC88 \uC785\uB825 \uC9C0\uC6D0, Enter \uD0A4\uB85C \uC885\uB8CC)",
+    singleLineHint: "\uC5EC\uB7EC \uBC88\uC758 \uD55C \uC904 \uC785\uB825\uC744 \uC9C0\uC6D0\uD558\uBA70, Enter \uD0A4\uB85C \uC885\uB8CC\uD569\uB2C8\uB2E4. \uC785\uB825\uC774 \uBE44\uC5B4 \uC788\uC73C\uBA74 \uAE30\uBCF8 \uBC84\uC804 \uC5C5\uADF8\uB808\uC774\uB4DC \uAE30\uB85D\uC774 \uC0AC\uC6A9\uB429\uB2C8\uB2E4",
+    empty: "changelog\uB294 \uBE44\uC5B4 \uC788\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+    generate: "CHANGELOG.md \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
+    usingDefault: "\uAE30\uBCF8 changelog \uC0AC\uC6A9: \uBC84\uC804 \uC5C5\uADF8\uB808\uC774\uB4DC \uAE30\uB85D",
+    defaultContent: "\uBC84\uC804 \uC5C5\uADF8\uB808\uC774\uB4DC: {currentVersion} \u2192 {newVersion}"
+  },
+  version: {
+    selectType: "\uBC84\uC804 \uC720\uD615 \uC120\uD0DD",
+    currentVersion: "\uD604\uC7AC \uBC84\uC804",
+    finalVersion: "\uCD5C\uC885 \uBC84\uC804",
+    customVersion: "\uC0AC\uC6A9\uC790 \uC815\uC758 \uBC84\uC804",
+    customVersionDesc: "\uBC84\uC804\uC744 \uC218\uB3D9\uC73C\uB85C \uC785\uB825",
+    inputVersion: "\uBC84\uC804 \uBC88\uD638\uB97C \uC785\uB825\uD558\uC138\uC694",
+    example: "\uC608",
+    versionEmpty: "\uBC84\uC804\uC740 \uBE44\uC5B4 \uC788\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+    patch: "\uD328\uCE58 \uBC84\uC804 - \uBC84\uADF8 \uC218\uC815",
+    minor: "\uB9C8\uC774\uB108 \uBC84\uC804 - \uC0C8 \uAE30\uB2A5, \uD558\uC704 \uD638\uD658",
+    major: "\uBA54\uC774\uC800 \uBC84\uC804 - \uC8FC\uC694 \uBCC0\uACBD \uC0AC\uD56D",
+    invalid: "\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uBC84\uC804 \uBC88\uD638",
+    invalidWithVersion: "\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uBC84\uC804 \uBC88\uD638: {version}",
+    cannotGenerate: "\uB2E4\uC74C \uBC84\uC804\uC744 \uC0DD\uC131\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+    unsupportedType: "\uC9C0\uC6D0\uB418\uC9C0 \uC54A\uB294 \uB9B4\uB9AC\uC2A4 \uC720\uD615",
+    unsupportedTypeWithType: "\uC9C0\uC6D0\uB418\uC9C0 \uC54A\uB294 \uB9B4\uB9AC\uC2A4 \uC720\uD615: {type}",
+    versionFormat: "{current} -> {next}"
+  },
+  script: {
+    select: "\uC2E4\uD589\uD560 \uC2A4\uD06C\uB9BD\uD2B8\uB97C \uC120\uD0DD\uD558\uC138\uC694 (\uBCF4\uD1B5 build)",
+    noScripts: "\uC774 \uD328\uD0A4\uC9C0\uC5D0\uB294 \uC2A4\uD06C\uB9BD\uD2B8\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4",
+    running: "\uC2A4\uD06C\uB9BD\uD2B8 \uC2E4\uD589 \uC911",
+    success: "\uC2A4\uD06C\uB9BD\uD2B8 \uC2E4\uD589 \uC131\uACF5",
+    failed: "\uC2A4\uD06C\uB9BD\uD2B8 \uC2E4\uD589 \uC2E4\uD328",
+    notFound: "\uC2A4\uD06C\uB9BD\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+    notFoundWithName: '\uC2A4\uD06C\uB9BD\uD2B8 "{name}"\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4',
+    executionFailed: "\uC2A4\uD06C\uB9BD\uD2B8 \uC2E4\uD589 \uC2E4\uD328, \uC885\uB8CC \uCF54\uB4DC: {exitCode}"
+  },
+  git: {
+    pushTag: "git tag\uB97C \uD478\uC2DC\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
+    createTagFailed: "git tag \uC0DD\uC131 \uC2E4\uD328, \uC885\uB8CC \uCF54\uB4DC: {exitCode}",
+    pushTagFailed: "git tag \uD478\uC2DC \uC2E4\uD328, \uC885\uB8CC \uCF54\uB4DC: {exitCode}"
+  },
+  registry: {
+    input: "npm registry \uC8FC\uC18C\uB97C \uC785\uB825\uD558\uC138\uC694",
+    empty: "registry \uC8FC\uC18C\uB294 \uBE44\uC5B4 \uC788\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+    invalid: "\uC720\uD6A8\uD55C URL\uC744 \uC785\uB825\uD558\uC138\uC694"
+  },
+  publish: {
+    preview: "\uAC8C\uC2DC \uAD6C\uC131 \uBBF8\uB9AC\uBCF4\uAE30",
+    packageName: "\uD328\uD0A4\uC9C0 \uC774\uB984",
+    currentVersion: "\uD604\uC7AC \uBC84\uC804",
+    newVersion: "\uC0C8 \uBC84\uC804",
+    tag: "Tag",
+    changelog: "Changelog",
+    registry: "Registry",
+    pushTag: "Tag \uD478\uC2DC",
+    generateChangelog: "Changelog \uC0DD\uC131",
+    script: "\uC2A4\uD06C\uB9BD\uD2B8",
+    confirm: "\uAC8C\uC2DC\uB97C \uD655\uC778\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
+    publishing: "npm\uC5D0 \uAC8C\uC2DC \uC911...",
+    success: "\uAC8C\uC2DC \uC131\uACF5!",
+    failed: "\uAC8C\uC2DC \uC2E4\uD328",
+    cancelled: "\uAC8C\uC2DC \uCDE8\uC18C\uB428",
+    error: "\uAC8C\uC2DC \uC911 \uC624\uB958 \uBC1C\uC0DD",
+    generalError: "\uC624\uB958",
+    npmPublishFailed: "npm \uAC8C\uC2DC \uC2E4\uD328, \uC885\uB8CC \uCF54\uB4DC: {exitCode}",
+    npmNotLoggedIn: "npm registry\uC5D0 \uB85C\uADF8\uC778\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4: {registry}\uFF0C\uBA3C\uC800 'npm login --registry {registry}'\uB97C \uC2E4\uD589\uD558\uC138\uC694",
+    npmAuthCheckFailed: "npm \uB85C\uADF8\uC778 \uC0C1\uD0DC \uD655\uC778 \uC2E4\uD328 (registry: {registry}): {error}",
+    needOtp: "npm \uAC8C\uC2DC \uC77C\uD68C\uC6A9 \uCF54\uB4DC(OTP)\uB97C \uC785\uB825\uD574\uC57C \uD569\uB2C8\uAE4C?",
+    inputOtp: "\uC77C\uD68C\uC6A9 \uCF54\uB4DC(OTP)\uB97C \uC785\uB825\uD558\uC138\uC694",
+    otpEmpty: "\uC77C\uD68C\uC6A9 \uCF54\uB4DC\uB294 \uBE44\uC5B4 \uC788\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+    otpInvalid: "\uC77C\uD68C\uC6A9 \uCF54\uB4DC\uB294 6\uC790\uB9AC \uC22B\uC790\uC5EC\uC57C \uD569\uB2C8\uB2E4",
+    otp: "\uC77C\uD68C\uC6A9 \uCF54\uB4DC(OTP)",
+    rollingBack: "\uAC8C\uC2DC \uC2E4\uD328, \uBCC0\uACBD \uC0AC\uD56D \uB864\uBC31 \uC911...",
+    rollbackComplete: "\uB864\uBC31 \uC644\uB8CC",
+    rollbackFailed: "\uB864\uBC31 \uC2E4\uD328, \uBC84\uC804\uACFC changelog\uB97C \uC218\uB3D9\uC73C\uB85C \uBCF5\uC6D0\uD558\uC138\uC694:"
+  },
+  success: {
+    title: "\uAC8C\uC2DC \uC131\uACF5!",
+    packageName: "\uD328\uD0A4\uC9C0 \uC774\uB984",
+    version: "\uBC84\uC804",
+    registry: "Registry",
+    thanks: "bun-push\uB97C \uC0AC\uC6A9\uD574 \uC8FC\uC154\uC11C \uAC10\uC0AC\uD569\uB2C8\uB2E4!"
+  },
+  changelogTypes: {
+    added: "\uCD94\uAC00\uB428",
+    changed: "\uBCC0\uACBD\uB428",
+    deprecated: "\uC0AC\uC6A9 \uC911\uB2E8\uB428",
+    removed: "\uC81C\uAC70\uB428",
+    fixed: "\uC218\uC815\uB428",
+    security: "\uBCF4\uC548"
+  },
+  workspace: {
+    packageJsonNotFound: "package.json \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+    workspacesConfigInvalid: "workspaces \uAD6C\uC131\uC774 \uC720\uD6A8\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+    packageNotFound: "\uD328\uD0A4\uC9C0\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+    packageNotFoundByPath: "\uACBD\uB85C {path}\uC5D0\uC11C \uD328\uD0A4\uC9C0\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+    monorepoRequiresPath: "monorepo \uBAA8\uB4DC\uC5D0\uC11C\uB294 packagePath\uB97C \uC9C0\uC815\uD558\uAC70\uB098 CLI \uBAA8\uB4DC\uB97C \uC0AC\uC6A9\uD574\uC57C \uD569\uB2C8\uB2E4"
+  }
+};
+
+// src/i18n/index.ts
+var SUPPORTED_LANGUAGES = ["zh", "en", "ja", "ko"];
+var translations = {
+  zh: zh_default,
+  en: en_default,
+  ja: ja_default,
+  ko: ko_default
+};
+var currentLanguage = "zh";
+function detectLanguage() {
+  const envLang = process.env.LANG || process.env.LANGUAGE || process.env.LC_ALL || process.env.LC_MESSAGES || "";
+  if (envLang) {
+    const langMatch = envLang.match(/(?:^|_|-)(zh|en|ja|ko)(?:[._-]|$)/i);
+    if (langMatch) {
+      const lang = langMatch[1].toLowerCase();
+      if (SUPPORTED_LANGUAGES.includes(lang)) {
+        return lang;
+      }
+    }
+  }
+  try {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    const lang = locale.split("-")[0].toLowerCase();
+    if (SUPPORTED_LANGUAGES.includes(lang)) {
+      return lang;
+    }
+  } catch {}
+  try {
+    const collator = new Intl.Collator;
+    const locale = collator.resolvedOptions().locale;
+    const lang = locale.split("-")[0].toLowerCase();
+    if (SUPPORTED_LANGUAGES.includes(lang)) {
+      return lang;
+    }
+  } catch {}
+  return "zh";
+}
+function initLanguage() {
+  const envLang = process.env.BUN_PUSH_LANG;
+  if (envLang && SUPPORTED_LANGUAGES.includes(envLang)) {
+    currentLanguage = envLang;
+    return;
+  }
+  currentLanguage = detectLanguage();
+}
+function t(key, params) {
+  const keys = key.split(".");
+  let value = translations[currentLanguage];
+  for (const k of keys) {
+    if (value && typeof value === "object" && k in value) {
+      value = value[k];
+    } else {
+      if (currentLanguage !== "zh") {
+        value = translations.zh;
+        for (const k2 of keys) {
+          if (value && typeof value === "object" && k2 in value) {
+            value = value[k2];
+          } else {
+            return key;
+          }
+        }
+      } else {
+        return key;
+      }
+    }
+  }
+  let result = typeof value === "string" ? value : key;
+  if (params) {
+    for (const [paramKey, paramValue] of Object.entries(params)) {
+      result = result.replace(new RegExp(`\\{${paramKey}\\}`, "g"), String(paramValue));
+    }
+  }
+  return result;
+}
+initLanguage();
+
+// src/utils/workspace.ts
+function readPackageJson(path) {
+  const packageJsonPath = join(path, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function isMonorepo(packageJson) {
+  if (packageJson.workspaces && Array.isArray(packageJson.workspaces)) {
+    return true;
+  }
+  if (packageJson.workspaces?.packages && Array.isArray(packageJson.workspaces.packages)) {
+    return true;
+  }
+  return false;
+}
+function parseWorkspacePatterns(workspaces) {
+  if (Array.isArray(workspaces)) {
+    return workspaces;
+  }
+  if (workspaces?.packages) {
+    return workspaces.packages;
+  }
+  return [];
+}
+function matchesPattern(path, pattern) {
+  const regex = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\//g, "\\/");
+  return new RegExp(`^${regex}$`).test(path);
+}
+function scanPackages(rootPath, patterns, found = []) {
+  const rootPackageJson = readPackageJson(rootPath);
+  if (!rootPackageJson) {
+    return found;
+  }
+  function scanDirectory(dir, depth = 0) {
+    if (depth > 10)
+      return;
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const relativePath = fullPath.startsWith(rootPath) ? fullPath.slice(rootPath.length).replace(/^[/\\]/, "") : fullPath;
+        if (entry.startsWith(".") || entry === "node_modules") {
+          continue;
+        }
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          const matches = patterns.some((pattern) => matchesPattern(relativePath, pattern));
+          if (matches) {
+            const packageJson = readPackageJson(fullPath);
+            if (packageJson && packageJson.name) {
+              found.push({
+                name: packageJson.name,
+                version: packageJson.version || "0.0.0",
+                path: fullPath,
+                packageJson
+              });
+            }
+          } else {
+            scanDirectory(fullPath, depth + 1);
+          }
+        }
+      }
+    } catch (error) {}
+  }
+  scanDirectory(rootPath);
+  return found;
+}
+function getWorkspaceInfo(workingDir = process.cwd()) {
+  const rootPath = resolve(workingDir);
+  const rootPackageJson = readPackageJson(rootPath);
+  if (!rootPackageJson) {
+    throw new Error(t("workspace.packageJsonNotFound"));
+  }
+  const isMonorepoProject = isMonorepo(rootPackageJson);
+  if (!isMonorepoProject) {
+    return {
+      isMonorepo: false,
+      packages: [
+        {
+          name: rootPackageJson.name || "unknown",
+          version: rootPackageJson.version || "0.0.0",
+          path: rootPath,
+          packageJson: rootPackageJson
+        }
+      ],
+      rootPackageJson,
+      rootPath
+    };
+  }
+  const workspaceConfig = rootPackageJson.workspaces;
+  const patterns = parseWorkspacePatterns(workspaceConfig);
+  if (patterns.length === 0) {
+    throw new Error(t("workspace.workspacesConfigInvalid"));
+  }
+  const packages = scanPackages(rootPath, patterns);
+  if (packages.length === 0 && rootPackageJson.name) {
+    packages.push({
+      name: rootPackageJson.name,
+      version: rootPackageJson.version || "0.0.0",
+      path: rootPath,
+      packageJson: rootPackageJson
+    });
+  }
+  return {
+    isMonorepo: true,
+    packages,
+    rootPackageJson,
+    rootPath
+  };
+}
+
+// src/prompts.ts
+import prompts from "prompts";
+import chalk from "chalk";
+
+// src/utils/version.ts
+import semver from "semver";
+var RELEASE_TYPES = ["patch", "minor", "major"];
+function getNextVersion(currentVersion, releaseType = "patch") {
+  if (!semver.valid(currentVersion)) {
+    throw new Error(t("version.invalidWithVersion", { version: currentVersion }));
+  }
+  const nextVersion = semver.inc(currentVersion, releaseType);
+  if (!nextVersion) {
+    throw new Error(t("version.cannotGenerate"));
+  }
+  return nextVersion;
+}
+function isValidVersion(version) {
+  if (!version || typeof version !== "string") {
+    return false;
+  }
+  const trimmed = version.trim();
+  if (!trimmed) {
+    return false;
+  }
+  const standardVersionPattern = /^\d+\.\d+\.\d+$/;
+  if (!standardVersionPattern.test(trimmed)) {
+    return false;
+  }
+  const valid = semver.valid(trimmed);
+  if (!valid) {
+    return false;
+  }
+  return valid === trimmed;
+}
+function generateTag(packageName, version) {
+  const nameWithoutScope = packageName.replace(/^@[^/]+\//, "");
+  return `${nameWithoutScope}@${version}`;
+}
+function getReleaseTypeDescription(type) {
+  const descriptions = {
+    patch: t("version.patch"),
+    minor: t("version.minor"),
+    major: t("version.major")
+  };
+  return descriptions[type];
+}
+
+// src/utils/scripts.ts
+function getPackageScripts(packageInfo) {
+  const scripts = packageInfo.packageJson.scripts;
+  if (!scripts || typeof scripts !== "object") {
+    return [];
+  }
+  return Object.keys(scripts);
+}
+async function runScript(packageInfo, scriptName) {
+  const scripts = packageInfo.packageJson.scripts;
+  if (!scripts || !scripts[scriptName]) {
+    throw new Error(t("script.notFoundWithName", { name: scriptName }));
+  }
+  const proc = Bun.spawn(["bun", "run", scriptName], {
+    cwd: packageInfo.path,
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(t("script.executionFailed", { exitCode }));
+  }
+}
+
+// src/prompts.ts
+async function selectPackage(packages) {
+  if (packages.length === 1) {
+    return packages[0];
+  }
+  const { value } = await prompts({
+    type: "select",
+    name: "value",
+    message: t("package.selectPackage"),
+    choices: packages.map((pkg) => ({
+      title: `${pkg.name} (${pkg.version})`,
+      value: pkg,
+      description: pkg.path
+    }))
+  });
+  if (!value) {
+    process.exit(0);
+  }
+  return value;
+}
+function generateDefaultChangelog(packageName, currentVersion, newVersion) {
+  return t("changelog.defaultContent", { packageName, currentVersion, newVersion });
+}
+async function inputChangelog(packageName, currentVersion, newVersion) {
+  const { createInterface } = await import("readline");
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  console.log(chalk.cyan(t("changelog.input")));
+  console.log(chalk.gray(t("changelog.singleLineHint")));
+  const lines = [];
+  let lineNumber = 1;
+  return new Promise((resolve2) => {
+    const promptLine = () => {
+      rl.setPrompt(chalk.gray(`[${lineNumber}] `));
+      rl.prompt();
+    };
+    promptLine();
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (trimmed === "" && lines.length > 0) {
+        rl.close();
+        return;
+      }
+      if (trimmed === "" && lines.length === 0) {
+        rl.close();
+        return;
+      }
+      if (trimmed !== "") {
+        lines.push(trimmed);
+        lineNumber++;
+        promptLine();
+      }
+    });
+    rl.on("close", () => {
+      const result = lines.join(`
+`).trim();
+      if (!result) {
+        const defaultChangelog = generateDefaultChangelog(packageName, currentVersion, newVersion);
+        console.log(chalk.yellow(t("changelog.usingDefault")));
+        resolve2(defaultChangelog);
+        return;
+      }
+      resolve2(result);
+    });
+    rl.on("SIGINT", () => {
+      rl.close();
+      process.exit(0);
+    });
+  });
+}
+async function confirmGenerateChangelog() {
+  const { value } = await prompts({
+    type: "confirm",
+    name: "value",
+    message: t("changelog.generate"),
+    initial: true
+  });
+  if (value === undefined) {
+    process.exit(0);
+  }
+  return value;
+}
+async function selectVersion(currentVersion) {
+  const choices = RELEASE_TYPES.map((type) => {
+    const nextVersion = getNextVersion(currentVersion, type);
+    return {
+      title: getReleaseTypeDescription(type),
+      value: type,
+      description: `${t("version.currentVersion")}: ${chalk.cyan(currentVersion)} \u2192 ${t("version.finalVersion")}: ${chalk.bold.green(nextVersion)}`
+    };
+  });
+  choices.push({
+    title: t("version.customVersion"),
+    value: "custom",
+    description: t("version.customVersionDesc")
+  });
+  const { value: releaseType } = await prompts({
+    type: "select",
+    name: "value",
+    message: `${t("version.currentVersion")}: ${chalk.cyan(currentVersion)} | ${t("version.selectType")}`,
+    choices
+  });
+  if (!releaseType) {
+    process.exit(0);
+  }
+  if (releaseType === "custom") {
+    const { value: customVersion } = await prompts({
+      type: "text",
+      name: "value",
+      message: `${t("version.inputVersion")} ${chalk.gray(`(${t("version.example")}: 1.0.0-beta.1)`)}`,
+      validate: (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+          return t("version.versionEmpty");
+        }
+        if (!isValidVersion(trimmed)) {
+          return t("version.invalidWithVersion", { version: trimmed });
+        }
+        return true;
+      }
+    });
+    if (!customVersion) {
+      process.exit(0);
+    }
+    const trimmedVersion = customVersion.trim();
+    if (!isValidVersion(trimmedVersion)) {
+      throw new Error(t("version.invalidWithVersion", { version: trimmedVersion }));
+    }
+    return {
+      version: trimmedVersion,
+      releaseType: "custom"
+    };
+  }
+  if (RELEASE_TYPES.includes(releaseType)) {
+    return {
+      version: getNextVersion(currentVersion, releaseType),
+      releaseType
+    };
+  }
+  throw new Error(t("version.unsupportedTypeWithType", { type: releaseType }));
+}
+async function selectScript(packageInfo) {
+  const scripts = getPackageScripts(packageInfo);
+  if (scripts.length === 0) {
+    return;
+  }
+  const choices = scripts.map((script) => ({
+    title: script,
+    value: script
+  }));
+  choices.push({
+    title: t("common.skip"),
+    value: "skip"
+  });
+  const { value: answer } = await prompts({
+    type: "select",
+    name: "value",
+    message: t("script.select"),
+    choices
+  });
+  if (!answer) {
+    process.exit(0);
+  }
+  return answer === "skip" ? undefined : answer;
+}
+async function confirmPushTag() {
+  const { value } = await prompts({
+    type: "confirm",
+    name: "value",
+    message: t("git.pushTag"),
+    initial: true
+  });
+  if (value === undefined) {
+    process.exit(0);
+  }
+  return value;
+}
+async function confirmOtp() {
+  const { value: needOtp } = await prompts({
+    type: "confirm",
+    name: "value",
+    message: t("publish.needOtp"),
+    initial: false
+  });
+  if (needOtp === undefined) {
+    process.exit(0);
+  }
+  if (!needOtp) {
+    return;
+  }
+  const { value: otp } = await prompts({
+    type: "text",
+    name: "value",
+    message: t("publish.inputOtp"),
+    validate: (input) => {
+      const trimmed = input.trim();
+      if (!trimmed) {
+        return t("publish.otpEmpty");
+      }
+      if (!/^\d{6}$/.test(trimmed)) {
+        return t("publish.otpInvalid");
+      }
+      return true;
+    }
+  });
+  if (!otp) {
+    process.exit(0);
+  }
+  return otp.trim();
+}
+async function confirmRegistry() {
+  const { value } = await prompts({
+    type: "text",
+    name: "value",
+    message: t("registry.input"),
+    initial: process.env.NPM_CONFIG_REGISTRY || "https://registry.npmjs.org/",
+    validate: (input) => {
+      if (!input.trim()) {
+        return t("registry.empty");
+      }
+      try {
+        new URL(input);
+        return true;
+      } catch {
+        return t("registry.invalid");
+      }
+    }
+  });
+  if (!value) {
+    process.exit(0);
+  }
+  return value.trim();
+}
+async function confirmPublish(config) {
+  console.log(chalk.bold(`
+\uD83D\uDCE6 ${t("publish.preview")}`));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log(chalk.cyan(`${t("publish.packageName")}:`), config.package.name);
+  console.log(chalk.cyan(`${t("publish.currentVersion")}:`), config.package.version);
+  console.log(chalk.cyan(`${t("publish.newVersion")}:`), config.newVersion);
+  console.log(chalk.cyan(`${t("publish.tag")}:`), config.tag);
+  console.log(chalk.cyan(`${t("publish.changelog")}:`), config.changelog);
+  console.log(chalk.cyan(`${t("publish.registry")}:`), config.registry);
+  console.log(chalk.cyan(`${t("publish.pushTag")}:`), config.pushTag ? t("common.yes") : t("common.no"));
+  console.log(chalk.cyan(`${t("publish.generateChangelog")}:`), config.generateChangelog ? t("common.yes") : t("common.no"));
+  if (config.otp) {
+    console.log(chalk.cyan(`${t("publish.otp")}:`), chalk.gray("***"));
+  }
+  if (config.script) {
+    console.log(chalk.cyan(`${t("publish.script")}:`), config.script);
+  }
+  console.log(chalk.gray("\u2500".repeat(50)));
+  const { value } = await prompts({
+    type: "confirm",
+    name: "value",
+    message: t("publish.confirm"),
+    initial: true
+  });
+  if (value === undefined) {
+    process.exit(0);
+  }
+  return value;
+}
+
+// src/publisher.ts
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, existsSync as existsSync3, unlinkSync } from "fs";
+import { join as join3 } from "path";
+
+// src/utils/changelog.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+function formatChangelogEntry(entry) {
+  const typeLabels = {
+    added: t("changelogTypes.added"),
+    changed: t("changelogTypes.changed"),
+    deprecated: t("changelogTypes.deprecated"),
+    removed: t("changelogTypes.removed"),
+    fixed: t("changelogTypes.fixed"),
+    security: t("changelogTypes.security")
+  };
+  return `- ${typeLabels[entry.type]}: ${entry.description}`;
+}
+function parseChangelog(changelogText) {
+  const entries = [];
+  const lines = changelogText.split(`
+`).filter((line) => line.trim());
+  const typeMaps = {
+    zh: { \u{65b0}\u{589e}: "added", \u{53d8}\u{66f4}: "changed", \u{5e9f}\u{5f03}: "deprecated", \u{79fb}\u{9664}: "removed", \u{4fee}\u{590d}: "fixed", \u{5b89}\u{5168}: "security" },
+    en: { Added: "added", Changed: "changed", Deprecated: "deprecated", Removed: "removed", Fixed: "fixed", Security: "security" },
+    ja: { \u{8ffd}\u{52a0}: "added", \u{5909}\u{66f4}: "changed", \u{975e}\u{63a8}\u{5968}: "deprecated", \u{524a}\u{9664}: "removed", \u{4fee}\u{6b63}: "fixed", \u{30bb}\u{30ad}\u{30e5}\u{30ea}\u{30c6}\u{30a3}: "security" },
+    ko: { \u{cd94}\u{ac00}\u{b428}: "added", \u{bcc0}\u{acbd}\u{b428}: "changed", \u{c0ac}\u{c6a9}\u{c911}\u{b2e8}\u{b428}: "deprecated", \u{c81c}\u{ac70}\u{b428}: "removed", \u{c218}\u{c815}\u{b428}: "fixed", \u{bcf4}\u{c548}: "security" }
+  };
+  const allTypeLabels = [];
+  for (const langMap of Object.values(typeMaps)) {
+    allTypeLabels.push(...Object.keys(langMap));
+  }
+  const typePattern = allTypeLabels.join("|");
+  for (const line of lines) {
+    const matchWithDash = line.match(new RegExp(`^-\\s*(${typePattern}):\\s*(.+)$`));
+    if (matchWithDash) {
+      const [, typeLabel, description] = matchWithDash;
+      let type;
+      for (const langMap of Object.values(typeMaps)) {
+        if (typeLabel in langMap) {
+          type = langMap[typeLabel];
+          break;
+        }
+      }
+      if (type) {
+        entries.push({ type, description: description.trim() });
+        continue;
+      }
+    }
+    const matchWithoutDash = line.match(new RegExp(`^(${typePattern}):\\s*(.+)$`));
+    if (matchWithoutDash) {
+      const [, typeLabel, description] = matchWithoutDash;
+      let type;
+      for (const langMap of Object.values(typeMaps)) {
+        if (typeLabel in langMap) {
+          type = langMap[typeLabel];
+          break;
+        }
+      }
+      if (type) {
+        entries.push({ type, description: description.trim() });
+        continue;
+      }
+    }
+    if (line.trim().startsWith("-")) {
+      const description = line.replace(/^-\s*/, "").trim();
+      if (description) {
+        entries.push({ type: "added", description });
+        continue;
+      }
+    }
+    const trimmedLine = line.trim();
+    if (trimmedLine) {
+      entries.push({ type: "added", description: trimmedLine });
+    }
+  }
+  return entries;
+}
+function generateChangelogSection(version, date, entries) {
+  const sections = {
+    added: [],
+    changed: [],
+    deprecated: [],
+    removed: [],
+    fixed: [],
+    security: []
+  };
+  for (const entry of entries) {
+    sections[entry.type].push(formatChangelogEntry(entry));
+  }
+  const lines = [];
+  lines.push(`## [${version}] - ${date}`);
+  lines.push("");
+  const typeOrder = ["added", "changed", "deprecated", "removed", "fixed", "security"];
+  for (const type of typeOrder) {
+    if (sections[type].length > 0) {
+      const typeLabels = {
+        added: `### ${t("changelogTypes.added")}`,
+        changed: `### ${t("changelogTypes.changed")}`,
+        deprecated: `### ${t("changelogTypes.deprecated")}`,
+        removed: `### ${t("changelogTypes.removed")}`,
+        fixed: `### ${t("changelogTypes.fixed")}`,
+        security: `### ${t("changelogTypes.security")}`
+      };
+      lines.push(typeLabels[type]);
+      lines.push("");
+      lines.push(...sections[type]);
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
+function readChangelog(packagePath) {
+  const changelogPath = join2(packagePath, "CHANGELOG.md");
+  if (!existsSync2(changelogPath)) {
+    return "";
+  }
+  try {
+    return readFileSync2(changelogPath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function updateChangelog(packagePath, version, changelogText) {
+  const changelogPath = join2(packagePath, "CHANGELOG.md");
+  const existingContent = readChangelog(packagePath);
+  const entries = parseChangelog(changelogText);
+  const date = new Date().toISOString().split("T")[0];
+  const newSection = generateChangelogSection(version, date, entries);
+  let newContent = "";
+  if (existingContent) {
+    const versionMatch = existingContent.match(/^##\s+\[/m);
+    if (versionMatch && versionMatch.index !== undefined) {
+      newContent = existingContent.slice(0, versionMatch.index) + newSection + `
+
+` + existingContent.slice(versionMatch.index);
+    } else {
+      newContent = newSection + `
+
+` + existingContent;
+    }
+  } else {
+    const lang = t("common.yes") === "\u662F" ? "zh-CN" : t("common.yes") === "Yes" ? "en" : t("common.yes") === "\u306F\u3044" ? "ja" : "ko";
+    const headers = {
+      "zh-CN": `# Changelog
+
+\u6240\u6709\u91CD\u8981\u7684\u9879\u76EE\u53D8\u66F4\u90FD\u4F1A\u8BB0\u5F55\u5728\u8FD9\u4E2A\u6587\u4EF6\u4E2D\u3002
+
+\u683C\u5F0F\u57FA\u4E8E [Keep a Changelog](https://keepachangelog.com/zh-CN/1.0.0/)\uFF0C
+\u672C\u9879\u76EE\u9075\u5FAA [\u8BED\u4E49\u5316\u7248\u672C](https://semver.org/lang/zh-CN/)\u3002
+
+`,
+      en: `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+`,
+      ja: `# Changelog
+
+\u3053\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306E\u91CD\u8981\u306A\u5909\u66F4\u306F\u3059\u3079\u3066\u3053\u306E\u30D5\u30A1\u30A4\u30EB\u306B\u8A18\u9332\u3055\u308C\u307E\u3059\u3002
+
+\u5F62\u5F0F\u306F [Keep a Changelog](https://keepachangelog.com/ja/1.0.0/) \u306B\u57FA\u3065\u3044\u3066\u304A\u308A\u3001
+\u3053\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306F [\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30D0\u30FC\u30B8\u30E7\u30CB\u30F3\u30B0](https://semver.org/lang/ja/) \u306B\u6E96\u62E0\u3057\u3066\u3044\u307E\u3059\u3002
+
+`,
+      ko: `# Changelog
+
+\uC774 \uD504\uB85C\uC81D\uD2B8\uC758 \uBAA8\uB4E0 \uC911\uC694\uD55C \uBCC0\uACBD \uC0AC\uD56D\uC740 \uC774 \uD30C\uC77C\uC5D0 \uAE30\uB85D\uB429\uB2C8\uB2E4.
+
+\uD615\uC2DD\uC740 [Keep a Changelog](https://keepachangelog.com/ko/1.0.0/)\uB97C \uAE30\uBC18\uC73C\uB85C \uD558\uBA70,
+\uC774 \uD504\uB85C\uC81D\uD2B8\uB294 [\uC2DC\uB9E8\uD2F1 \uBC84\uC804 \uAD00\uB9AC](https://semver.org/lang/ko/)\uB97C \uC900\uC218\uD569\uB2C8\uB2E4.
+
+`
+    };
+    newContent = `${headers[lang] || headers.en}${newSection}
+`;
+  }
+  writeFileSync(changelogPath, newContent, "utf-8");
+}
+
+// src/publisher.ts
+function readPackageVersion(packagePath) {
+  const packageJsonPath = join3(packagePath, "package.json");
+  const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+  return packageJson.version;
+}
+function updatePackageVersion(packagePath, newVersion) {
+  const packageJsonPath = join3(packagePath, "package.json");
+  const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+  packageJson.version = newVersion;
+  writeFileSync2(packageJsonPath, JSON.stringify(packageJson, null, 2) + `
+`, "utf-8");
+}
+function restorePackageVersion(packagePath, oldVersion) {
+  updatePackageVersion(packagePath, oldVersion);
+}
+function restoreChangelog(packagePath, oldContent) {
+  const changelogPath = join3(packagePath, "CHANGELOG.md");
+  if (oldContent === "") {
+    if (existsSync3(changelogPath)) {
+      try {
+        unlinkSync(changelogPath);
+      } catch (error) {
+        writeFileSync2(changelogPath, "", "utf-8");
+      }
+    }
+  } else {
+    writeFileSync2(changelogPath, oldContent, "utf-8");
+  }
+}
+async function createGitTag(tag) {
+  const proc = Bun.spawn(["git", "tag", tag], {
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(t("git.createTagFailed", { exitCode }));
+  }
+}
+async function deleteGitTag(tag) {
+  const proc = Bun.spawn(["git", "tag", "-d", tag], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  await proc.exited;
+}
+async function pushGitTag(tag) {
+  const proc = Bun.spawn(["git", "push", "origin", tag], {
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(t("git.pushTagFailed", { exitCode }));
+  }
+}
+async function checkNpmAuth(registry) {
+  const proc = Bun.spawn(["bun", "pm", "whoami"], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    const errorMsg = stderr.trim();
+    if (errorMsg.includes("not logged in") || errorMsg.includes("Unauthorized") || errorMsg === "") {
+      throw new Error(t("publish.npmNotLoggedIn", { registry }));
+    }
+    throw new Error(t("publish.npmAuthCheckFailed", { registry, error: errorMsg }));
+  }
+  const stdout = await new Response(proc.stdout).text();
+  const username = stdout.trim();
+  if (!username) {
+    throw new Error(t("publish.npmNotLoggedIn", { registry }));
+  }
+}
+async function publishToNpm(packagePath, registry, otp) {
+  const args = ["bun", "publish", "--registry", registry];
+  if (otp) {
+    args.push("--otp", otp);
+  }
+  const proc = Bun.spawn(args, {
+    cwd: packagePath,
+    stdout: "inherit",
+    stderr: "inherit",
+    env: {
+      ...process.env,
+      NPM_CONFIG_REGISTRY: registry
+    }
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    return Promise.reject(new Error(t("publish.npmPublishFailed", { exitCode })));
+  }
+}
+async function publish(config) {
+  const originalVersion = readPackageVersion(config.package.path);
+  const originalChangelog = config.generateChangelog ? readChangelog(config.package.path) : "";
+  let gitTagCreated = false;
+  try {
+    updatePackageVersion(config.package.path, config.newVersion);
+    if (config.generateChangelog) {
+      updateChangelog(config.package.path, config.newVersion, config.changelog);
+    }
+    await checkNpmAuth(config.registry);
+    if (config.pushTag) {
+      await createGitTag(config.tag);
+      gitTagCreated = true;
+    }
+    await publishToNpm(config.package.path, config.registry, config.otp);
+    if (config.pushTag) {
+      await pushGitTag(config.tag);
+    }
+  } catch (error) {
+    console.error(t("publish.rollingBack") || "\u53D1\u5E03\u5931\u8D25\uFF0C\u6B63\u5728\u56DE\u6EDA\u4FEE\u6539...");
+    try {
+      restorePackageVersion(config.package.path, originalVersion);
+      if (config.generateChangelog) {
+        restoreChangelog(config.package.path, originalChangelog);
+      }
+      if (gitTagCreated) {
+        await deleteGitTag(config.tag);
+      }
+      console.error(t("publish.rollbackComplete") || "\u56DE\u6EDA\u5B8C\u6210");
+    } catch (rollbackError) {
+      console.error(t("publish.rollbackFailed") || "\u56DE\u6EDA\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6062\u590D\u7248\u672C\u53F7\u548C changelog:", rollbackError);
+    }
+    throw error;
+  }
+}
+
+// src/logo.ts
+import chalk2 from "chalk";
+import figlet from "figlet";
+function showLogo() {
+  try {
+    const asciiText = figlet.textSync("bun-push", {
+      font: "Standard",
+      horizontalLayout: "default",
+      verticalLayout: "default"
+    });
+    const lines = asciiText.split(`
+`).filter((line) => line.trim().length > 0);
+    if (lines.length === 0) {
+      console.log(chalk2.cyan.bold(`
+  bun-push
+`));
+      return;
+    }
+    const coloredLines = lines.map((line, index) => {
+      const midPoint = Math.floor(line.length / 2);
+      if (index < lines.length / 2) {
+        return chalk2.red(line.substring(0, midPoint)) + chalk2.yellow(line.substring(midPoint));
+      } else {
+        return chalk2.magenta(line.substring(0, midPoint)) + chalk2.blue(line.substring(midPoint));
+      }
+    });
+    const logo = `
+` + coloredLines.join(`
+`) + `
+`;
+    console.log(logo);
+  } catch (error) {
+    console.log(chalk2.cyan.bold(`
+  bun-push
+`));
+  }
+}
+function showSuccessMessage(packageName, version, registry) {
+  console.log(chalk2.green.bold(`
+\u2705 ${t("success.title")}
+`));
+  console.log(chalk2.gray("\u2500".repeat(60)));
+  console.log(chalk2.cyan.bold(`\uD83D\uDCE6 ${t("success.packageName")}:`), chalk2.white(packageName));
+  console.log(chalk2.cyan.bold(`\uD83C\uDFF7\uFE0F  ${t("success.version")}:`), chalk2.white(version));
+  console.log(chalk2.cyan.bold(`\uD83C\uDF10 ${t("success.registry")}:`), chalk2.white(registry));
+  console.log(chalk2.gray("\u2500".repeat(60)));
+  console.log(chalk2.green(`
+\uD83C\uDF89 ${t("success.thanks")}
+`));
+}
+
+// src/cli.ts
+async function main() {
+  try {
+    showLogo();
+    const workspaceInfo = getWorkspaceInfo();
+    let selectedPackage;
+    if (workspaceInfo.isMonorepo) {
+      selectedPackage = await selectPackage(workspaceInfo.packages);
+    } else {
+      selectedPackage = workspaceInfo.packages[0];
+    }
+    console.log(chalk3.green(`
+\u2705 ${t("package.selectedPackage")}: ${chalk3.bold(selectedPackage.name)} (${selectedPackage.version})`));
+    const { version: newVersion } = await selectVersion(selectedPackage.version);
+    const changelog = await inputChangelog(selectedPackage.name, selectedPackage.version, newVersion);
+    const tag = generateTag(selectedPackage.name, newVersion);
+    const script = await selectScript(selectedPackage);
+    if (script) {
+      const spinner = ora(`${t("script.running")}: ${chalk3.cyan(script)}`).start();
+      try {
+        await runScript(selectedPackage, script);
+        spinner.succeed(`${t("script.success")}: ${chalk3.cyan(script)}`);
+      } catch (error) {
+        spinner.fail(`${t("script.failed")}: ${chalk3.red(script)}`);
+        throw error;
+      }
+    }
+    const pushTag = await confirmPushTag();
+    const registry = await confirmRegistry();
+    const generateChangelog = await confirmGenerateChangelog();
+    const otp = await confirmOtp();
+    const config = {
+      package: selectedPackage,
+      changelog,
+      newVersion,
+      tag,
+      script,
+      pushTag,
+      registry,
+      generateChangelog,
+      otp
+    };
+    const confirmed = await confirmPublish(config);
+    if (!confirmed) {
+      console.log(chalk3.yellow(`
+\u274C ${t("publish.cancelled")}`));
+      process.exit(0);
+    }
+    const publishSpinner = ora(t("publish.publishing")).start();
+    try {
+      await publish(config);
+      publishSpinner.succeed(t("publish.success"));
+      showSuccessMessage(selectedPackage.name, newVersion, registry);
+    } catch (error) {
+      publishSpinner.fail(t("publish.failed"));
+      console.error(chalk3.red(`
+\u274C ${t("publish.error")}:`), error);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk3.red(`
+\u274C ${t("publish.generalError")}:`), error);
+    process.exit(1);
+  }
+}
+main();
+
+//# debugId=5DAA9E169C926ABE64756E2164756E21