create-windy 0.1.1 → 0.2.0

package/dist/cli.js

@@ -1,4 +1,197 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  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: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../../node_modules/.bun/cli-width@4.1.0/node_modules/cli-width/index.js
+var require_cli_width = __commonJS((exports, module3) => {
+  module3.exports = cliWidth;
+  function normalizeOpts(options) {
+    const defaultOpts = {
+      defaultWidth: 0,
+      output: process.stdout,
+      tty: __require("tty")
+    };
+    if (!options) {
+      return defaultOpts;
+    }
+    Object.keys(defaultOpts).forEach(function(key) {
+      if (!options[key]) {
+        options[key] = defaultOpts[key];
+      }
+    });
+    return options;
+  }
+  function cliWidth(options) {
+    const opts = normalizeOpts(options);
+    if (opts.output.getWindowSize) {
+      return opts.output.getWindowSize()[0] || opts.defaultWidth;
+    }
+    if (opts.tty.getWindowSize) {
+      return opts.tty.getWindowSize()[1] || opts.defaultWidth;
+    }
+    if (opts.output.columns) {
+      return opts.output.columns;
+    }
+    if (process.env.CLI_WIDTH) {
+      const width = parseInt(process.env.CLI_WIDTH, 10);
+      if (!isNaN(width) && width !== 0) {
+        return width;
+      }
+    }
+    return opts.defaultWidth;
+  }
+});
+
+// ../../node_modules/.bun/mute-stream@3.0.0/node_modules/mute-stream/lib/index.js
+var require_lib = __commonJS((exports, module3) => {
+  var Stream = __require("stream");
+
+  class MuteStream extends Stream {
+    #isTTY = null;
+    constructor(opts = {}) {
+      super(opts);
+      this.writable = this.readable = true;
+      this.muted = false;
+      this.on("pipe", this._onpipe);
+      this.replace = opts.replace;
+      this._prompt = opts.prompt || null;
+      this._hadControl = false;
+    }
+    #destSrc(key, def) {
+      if (this._dest) {
+        return this._dest[key];
+      }
+      if (this._src) {
+        return this._src[key];
+      }
+      return def;
+    }
+    #proxy(method, ...args) {
+      if (typeof this._dest?.[method] === "function") {
+        this._dest[method](...args);
+      }
+      if (typeof this._src?.[method] === "function") {
+        this._src[method](...args);
+      }
+    }
+    get isTTY() {
+      if (this.#isTTY !== null) {
+        return this.#isTTY;
+      }
+      return this.#destSrc("isTTY", false);
+    }
+    set isTTY(val) {
+      this.#isTTY = val;
+    }
+    get rows() {
+      return this.#destSrc("rows");
+    }
+    get columns() {
+      return this.#destSrc("columns");
+    }
+    mute() {
+      this.muted = true;
+    }
+    unmute() {
+      this.muted = false;
+    }
+    _onpipe(src) {
+      this._src = src;
+    }
+    pipe(dest, options) {
+      this._dest = dest;
+      return super.pipe(dest, options);
+    }
+    pause() {
+      if (this._src) {
+        return this._src.pause();
+      }
+    }
+    resume() {
+      if (this._src) {
+        return this._src.resume();
+      }
+    }
+    write(c) {
+      if (this.muted) {
+        if (!this.replace) {
+          return true;
+        }
+        if (c.match(/^\u001b/)) {
+          if (c.indexOf(this._prompt) === 0) {
+            c = c.slice(this._prompt.length);
+            c = c.replace(/./g, this.replace);
+            c = this._prompt + c;
+          }
+          this._hadControl = true;
+          return this.emit("data", c);
+        } else {
+          if (this._prompt && this._hadControl && c.indexOf(this._prompt) === 0) {
+            this._hadControl = false;
+            this.emit("data", this._prompt);
+            c = c.slice(this._prompt.length);
+          }
+          c = c.toString().replace(/./g, this.replace);
+        }
+      }
+      this.emit("data", c);
+    }
+    end(c) {
+      if (this.muted) {
+        if (c && this.replace) {
+          c = c.toString().replace(/./g, this.replace);
+        } else {
+          c = null;
+        }
+      }
+      if (c) {
+        this.emit("data", c);
+      }
+      this.emit("end");
+    }
+    destroy(...args) {
+      return this.#proxy("destroy", ...args);
+    }
+    destroySoon(...args) {
+      return this.#proxy("destroySoon", ...args);
+    }
+    close(...args) {
+      return this.#proxy("close", ...args);
+    }
+  }
+  module3.exports = MuteStream;
+});
 
 // src/arguments.ts
 import { resolve } from "node:path";
@@ -495,6 +688,12 @@ function readProjectLicense(args) {
 }
 var helpText = `create-windy <项目名> [选项]
 
+生命周期命令：
+  create-windy doctor [--cwd <目录>] [--repair]
+  create-windy update --check [--cwd <目录>]
+  create-windy update --dry-run [--to <版本>] [--cwd <目录>]
+  create-windy update [--to <版本>] [--cwd <目录>]
+
 选项：
   --profile private-enterprise  单组织、单租户、私有部署 profile
   --skip-install                只生成文件，不执行 bun install
@@ -606,7 +805,7 @@ function isMissingCommand(error) {
 }
 
 // src/git.ts
-async function initializeGitRepository(targetDirectory, execute = runCommand) {
+async function initializeGitRepository(targetDirectory, execute = runCommand, activateHooks = false) {
   try {
     await execute("git", ["init", "-b", "main"], targetDirectory);
   } catch (error) {
@@ -615,6 +814,16 @@ async function initializeGitRepository(targetDirectory, execute = runCommand) {
       warning: `未能初始化 Git 仓库，项目文件已保留。${recoveryHint(error)}`
     };
   }
+  if (activateHooks) {
+    try {
+      await execute("bun", ["run", "prepare"], targetDirectory);
+    } catch (error) {
+      return {
+        status: "skipped",
+        warning: "Git 仓库已初始化，但提交钩子未能启用。请安装依赖后运行 bun run prepare。" + compactReason(error)
+      };
+    }
+  }
   try {
     await execute("git", ["add", "--all"], targetDirectory);
   } catch (error) {
@@ -681,8 +890,9 @@ function rewriteCustomerDockerfile(source) {
 import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 var oxcStarterPolicy = [
-  "- 代码检查与格式化统一使用 Oxc：Oxlint 和 Oxfmt，不使用 ESLint 或 Prettier。",
-  "- Oxc 是 Starter 默认提供的代码质量方案；项目生成后由项目所有者决定是否保留、替换或并行使用其它工具。"
+  "- 生成时默认预装 Oxlint、Oxfmt、lint-staged 与 Husky。",
+  "- 提交前自动格式化暂存文件；lint、typecheck 和 test 保留为显式命令。",
+  "- 这是 Starter 的初始配置；项目所有者可按团队需要保留、替换或扩展。"
 ].join(`
 `);
 var noCodeQualityPolicy = "- 本项目生成时未引入 lint 或 format 工具；项目所有者可按团队需要自行选择。";
@@ -702,7 +912,13 @@ import { mkdir, readFile as readFile3, rm, writeFile as writeFile3 } from "node:
 import { dirname, join as join3, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var packageRoot = resolve2(dirname(fileURLToPath(import.meta.url)), "..");
-var apacheLicensePath = resolve2(packageRoot, "assets/LICENSE-Apache-2.0.txt");
+var apacheLicensePath = resolve2(packageRoot, "LICENSE");
+var windyLicensePath = ".windy/licenses/WINDY-APACHE-2.0.txt";
+async function applyWindyBaseLicense(targetDirectory) {
+  const target = join3(targetDirectory, windyLicensePath);
+  await mkdir(dirname(target), { recursive: true });
+  await writeFile3(target, await readFile3(apacheLicensePath));
+}
 async function applyProjectLicense(targetDirectory, license, holder, year = new Date().getFullYear()) {
   const target = join3(targetDirectory, "LICENSE");
   if (license === "UNLICENSED") {
@@ -751,7 +967,11 @@ import { lstat, readdir, readFile as readFile4, writeFile as writeFile4 } from "
 import { join as join4, relative, sep } from "node:path";
 var managedFilesManifestPath = ".windy/files.json";
 var ignoredDirectoryNames = new Set([".git", "node_modules", "dist"]);
-var ignoredFiles = new Set(["bun.lock", managedFilesManifestPath]);
+var ignoredFiles = new Set([
+  "bun.lock",
+  managedFilesManifestPath,
+  ".windy/update-state.json"
+]);
 var projectOwnedRoots = [
   "apps/web/src/app",
   "apps/server/src/work-order",
@@ -784,6 +1004,16 @@ async function writeManagedFilesManifest(targetDirectory, generatorVersion) {
   await writeFile4(join4(targetDirectory, managedFilesManifestPath), `${JSON.stringify(manifest, null, 2)}
 `);
 }
+async function readManagedFilesManifest(targetDirectory) {
+  const parsed = JSON.parse(await readFile4(join4(targetDirectory, managedFilesManifestPath), "utf8"));
+  if (!isManagedFilesManifest(parsed)) {
+    throw new Error("受管文件清单无效，无法安全更新");
+  }
+  return parsed;
+}
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
 function classifyOwnership(path) {
   if (matchesRoot(path, projectOwnedRoots))
     return "project-owned";
@@ -804,6 +1034,10 @@ async function collectFiles(root) {
       if (metadata.isSymbolicLink())
         continue;
       if (metadata.isDirectory()) {
+        const relativeDirectory = relative(root, path).split(sep).join("/");
+        if (relativeDirectory === ".windy/backups" || relativeDirectory === ".windy/reports") {
+          continue;
+        }
         await visit(path, output);
         continue;
       }
@@ -816,6 +1050,17 @@ async function collectFiles(root) {
 function matchesRoot(path, roots) {
   return roots.some((root) => path === root || path.startsWith(`${root}/`));
 }
+function isManagedFilesManifest(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const manifest = value;
+  return manifest.schemaVersion === 1 && manifest.algorithm === "sha256" && typeof manifest.generatorVersion === "string" && Array.isArray(manifest.files) && manifest.files.every((entry) => {
+    if (!entry || typeof entry !== "object")
+      return false;
+    const file = entry;
+    return typeof file.path === "string" && (file.ownership === "windy-managed" || file.ownership === "shared-scaffold" || file.ownership === "project-owned") && typeof file.hash === "string";
+  });
+}
 
 // src/module-materializer.ts
 import { lstat as lstat2, readFile as readFile5, readdir as readdir2, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
@@ -1101,8 +1346,10 @@ ${projectName} 是由 create-windy 生成的单组织、单租户企业应用项
 \`/\`，平台管理控制面位于 \`/admin/**\`；业务功能可以按自己的产品习惯开发，不需要
 复用 Admin 页面结构。
 
-本项目固定使用 Bun 1.3.14 或更高版本，当前法律许可为 \`${projectLicense}\`。项目不包含
-软件供应方的 License Authority、内部签名服务、发布密钥或私有源仓库信息。
+本项目固定使用 Bun 1.3.14 或更高版本，客户业务代码的当前法律许可为
+\`${projectLicense}\`。Windy Starter 基座使用 Apache-2.0，正文保留在
+\`.windy/licenses/WINDY-APACHE-2.0.txt\`。项目不包含软件供应方的 License Authority、
+内部签名服务、发布密钥或私有源仓库信息。
 ${includeExample ? "创建时包含了 `work-order` 示例模块，用于演示 Module Manifest 接入；它不是生产工单产品，可以在正式开发前替换。" : "创建时未选择 `work-order` 示例模块，当前项目只包含平台模块。"}
 
 ## 环境要求
@@ -1169,8 +1416,9 @@ bun run dev:web
 | ---------- | -------- | ------------ | ---- |
 ${moduleRows}
 
-精确生成来源和选择记录在 \`.windy/generation.json\`。当前版本尚未提供通用
-\`module add/remove\` 或 \`windy update\`，不要把 Feature Flag 关闭当成模块已经卸载。
+精确生成来源和选择记录在 \`.windy/generation.json\`。当前版本已提供可回滚的
+\`windy update\`；通用 \`module add/remove\` 尚未交付，不要把 Feature Flag 关闭当成
+模块已经卸载。
 
 ## 常用命令
 
@@ -1180,10 +1428,19 @@ bun run dev:server
 bun run typecheck
 bun run test
 bun run build
+bun run windy doctor
+bun run windy update --check
+bun run windy update --dry-run
 ${includeOxc ? `bun run lint
 bun run format` : "# 本项目未预装 lint/format 工具，可按团队需要自行选择。"}
 \`\`\`
 
+${includeOxc ? "提交时 Husky 会通过 lint-staged 与 Oxfmt 格式化暂存文件，不会把未暂存内容带入提交。lint、typecheck 和 test 保留为需要时显式运行的命令。" : "当前项目没有生成 Husky 代码质量钩子；如后续自行引入工具，请同步配置提交工作流。"}
+
+更新前必须保持 Git 工作区干净。\`--dry-run\` 只生成计划，不写项目；正式更新先备份，
+再做 package 字段级合并、共享脚手架三方合并与完整验证。任何冲突都会在写入前中止，
+验证失败会自动回滚；中断恢复使用 \`bun run windy doctor --repair\`。
+
 ## 开发约束
 
 - 新增路由默认需要登录；只有显式 public 的页面允许匿名访问。
@@ -1206,27 +1463,40 @@ create-windy 默认建立 \`main\` 分支并创建 \`chore: initialize project\`
 
 ## License
 
-本项目当前法律许可证为 \`${projectLicense}\`。${projectLicense === "UNLICENSED" ? "项目没有附带开源许可证。" : "完整许可证正文位于根目录 `LICENSE`。"}法律许可证与 \`system.license\` 离线运行时授权模块是两个不同概念；更换其中一个
-不会自动更换另一个。
+客户业务代码当前法律许可证为 \`${projectLicense}\`。${projectLicense === "UNLICENSED" ? "项目没有附带开源许可证。" : "完整许可证正文位于根目录 `LICENSE`。"}Windy Starter 基座继续适用
+\`.windy/licenses/WINDY-APACHE-2.0.txt\` 中的 Apache-2.0。项目法律许可证与
+\`system.license\` 离线运行时授权模块是两个不同概念；更换其中一个不会自动更换
+另一个。
 `;
 }
 
 // src/project-package.ts
-function createStarterPackage(source, projectName, includeOxc = true, projectLicense = "UNLICENSED", selectedModules = []) {
+var defaultLintStaged = {
+  "*.{cjs,css,cts,html,js,json,jsonc,jsx,less,md,mdx,mjs,mts,scss,ts,tsx,vue,yaml,yml}": "oxfmt --write"
+};
+function createStarterPackage(source, projectName, includeOxc = true, projectLicense = "UNLICENSED", selectedModules = [], generatorVersion) {
+  const { "lint-staged": sourceLintStaged, ...sourceWithoutLintStaged } = source;
   const devDependencies = { ...source.devDependencies };
   if (!includeOxc) {
+    delete devDependencies.husky;
+    delete devDependencies["lint-staged"];
     delete devDependencies.oxfmt;
     delete devDependencies.oxlint;
   }
   return {
-    ...source,
+    ...sourceWithoutLintStaged,
     name: projectName,
     private: true,
     license: projectLicense,
     packageManager: "bun@1.3.14",
     engines: { ...source.engines, bun: ">=1.3.14" },
+    ...includeOxc ? { "lint-staged": sourceLintStaged ?? defaultLintStaged } : {},
     scripts: {
+      ...includeOxc ? {
+        prepare: "git rev-parse --git-dir >/dev/null 2>&1 || exit 0; husky"
+      } : {},
       dev: "bun run --cwd apps/web dev",
+      ...generatorVersion ? { windy: "create-windy" } : {},
       "dev:web": "bun run --cwd apps/web dev",
       "dev:server": "bun run --cwd apps/server dev",
       build: "bun run --cwd apps/web build",
@@ -1241,10 +1511,17 @@ function createStarterPackage(source, projectName, includeOxc = true, projectLic
         "bun run --cwd packages/database typecheck",
         "bun run --cwd packages/crud-generator typecheck"
       ].join(" && "),
-      ...includeOxc ? { lint: "oxlint .", format: "oxfmt" } : {},
+      ...includeOxc ? {
+        lint: "oxlint .",
+        format: "oxfmt",
+        "format:staged": "lint-staged"
+      } : {},
       test: "bun test && bun run --cwd apps/web test"
     },
-    devDependencies
+    devDependencies: {
+      ...devDependencies,
+      ...generatorVersion ? { "create-windy": generatorVersion } : {}
+    }
   };
 }
 
@@ -1252,6 +1529,7 @@ function createStarterPackage(source, projectName, includeOxc = true, projectLic
 var templateRootFiles = [
   ".dockerignore",
   ".gitignore",
+  ".husky/pre-commit",
   ".oxfmtrc.json",
   ".oxlintrc.json",
   "AGENTS.md",
@@ -1312,8 +1590,13 @@ var npmTemplateAliases = {
   "bunfig.toml": "_bunfig.toml"
 };
 function generationTemplatePaths(includeExample, includeOxc = true) {
-  return templatePaths.filter((path) => (includeExample || path !== "packages/example-work-order") && (includeOxc || path !== ".oxfmtrc.json" && path !== ".oxlintrc.json"));
+  return templatePaths.filter((path) => (includeExample || path !== "packages/example-work-order") && (includeOxc || !oxcTemplatePaths.has(path)));
 }
+var oxcTemplatePaths = new Set([
+  ".husky/pre-commit",
+  ".oxfmtrc.json",
+  ".oxlintrc.json"
+]);
 var excludedNames = new Set([
   ".DS_Store",
   ".env",
@@ -1341,6 +1624,14 @@ async function readTemplateMetadata(sourceRoot) {
   }
   return parsed;
 }
+async function readGenerationProvenance(targetDirectory) {
+  const path = join6(targetDirectory, generationMetadataFile);
+  const parsed = JSON.parse(await readFile6(path, "utf8"));
+  if (!isGenerationProvenance(parsed)) {
+    throw new Error("当前目录不是受支持的 Windy 项目：Project Lock 无效");
+  }
+  return parsed;
+}
 async function writeGenerationProvenance(targetDirectory, metadata, profile, selectedModules, includeOxc, legalLicense) {
   const requested = selectedModuleManifests(selectedModules);
   const versions = new Map(metadata.modules.map((item) => [item.name, item]));
@@ -1378,6 +1669,14 @@ function isTemplateMetadata(value) {
   const metadata = value;
   return metadata.schemaVersion === 1 && typeof metadata.templateCommit === "string" && /^[0-9a-f]{40}$/.test(metadata.templateCommit) && typeof metadata.generatorVersion === "string" && metadata.generatorVersion.length > 0 && Array.isArray(metadata.modules) && metadata.modules.every(isModuleVersion);
 }
+function isGenerationProvenance(value) {
+  if (!isTemplateMetadata(value))
+    return false;
+  const metadata = value;
+  const toolchain = metadata.toolchain;
+  const choices = metadata.choices;
+  return typeof metadata.windyVersion === "string" && metadata.profile === "private-enterprise" && toolchain?.runtime === "bun" && (toolchain?.codeQuality === "oxc" || toolchain?.codeQuality === "none") && (metadata.legalLicense === "UNLICENSED" || metadata.legalLicense === "MIT" || metadata.legalLicense === "Apache-2.0") && Array.isArray(metadata.appliedRecipes) && metadata.appliedRecipes.every((item) => typeof item === "string") && metadata.managedFilesManifest === ".windy/files.json" && typeof choices?.includeExample === "boolean" && typeof choices.includeOxc === "boolean";
+}
 function isModuleVersion(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -1401,13 +1700,14 @@ async function generateProject(input) {
   await materializeSelectedModules(input.targetDirectory, selectedModules);
   const packagePath = join7(input.targetDirectory, "package.json");
   const packageJson = JSON.parse(await readFile7(packagePath, "utf8"));
-  await writeFile7(packagePath, `${JSON.stringify(createStarterPackage(packageJson, input.projectName, includeOxc, projectLicense, selectedModules), null, 2)}
+  await writeFile7(packagePath, `${JSON.stringify(createStarterPackage(packageJson, input.projectName, includeOxc, projectLicense, selectedModules, templateMetadata.generatorVersion), null, 2)}
 `);
   await writeFile7(join7(input.targetDirectory, "docker-compose.yml"), starterCompose);
   await writeFile7(join7(input.targetDirectory, ".env.example"), environmentExample(includeExample));
   await writeFile7(join7(input.targetDirectory, "README.md"), starterReadme(input.projectName, includeExample, includeOxc, projectLicense, selectedModules));
   await writeFile7(join7(input.targetDirectory, "docs/README.md"), starterDocsReadme(selectedModules.includes("system.license")));
   await reflectCodeQualityChoice(input.targetDirectory, includeOxc);
+  await applyWindyBaseLicense(input.targetDirectory);
   await applyProjectLicense(input.targetDirectory, projectLicense, input.licenseHolder);
   await prepareCustomerDockerfiles(input.targetDirectory);
   await writeGenerationProvenance(input.targetDirectory, templateMetadata, input.profile ?? starterProfile.key, selectedModules, includeOxc, projectLicense);
@@ -1536,7 +1836,7 @@ async function createProject(options, dependencies = {}) {
   const log = dependencies.log ?? console.log;
   let gitInitialized = false;
   if (options.initializeGit) {
-    const result = await (dependencies.initializeGit ?? initializeGitRepository)(options.targetDirectory, dependencies.commandExecutor);
+    const result = await (dependencies.initializeGit ?? initializeGitRepository)(options.targetDirectory, dependencies.commandExecutor, options.includeOxc && (options.install || options.verify));
     gitInitialized = result.status === "committed";
     if (result.status === "skipped")
       log(`
@@ -1579,95 +1879,2489 @@ function isMissing3(error) {
 }
 
 // src/interactive-selection.ts
-import { createInterface } from "node:readline/promises";
+import { createInterface as createInterface2 } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
-async function applyInteractiveSelection(options, prompter = terminalPrompter()) {
-  if (!options.interactive)
-    return options;
-  const optional = moduleDistributionCatalog.filter(({ name }) => !requiredModuleNames.includes(name));
-  const requested = await prompter.selectModules({
-    choices: optional.map(({ name, label, selection }) => ({
-      value: name,
-      label: `${label} (${name})`,
-      hint: selection === "recommended" ? "推荐，默认选中" : "可选"
-    })),
-    defaults: [...recommendedModuleNames]
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/key.js
+var keybindings = ["emacs", "vim"];
+var keybindingLookup = new Set(keybindings);
+function isKeybinding(value) {
+  return keybindingLookup.has(value);
+}
+function getDefaultKeybindings() {
+  const env = process.env["INQUIRER_KEYBINDINGS"];
+  if (!env)
+    return [];
+  return Array.from(new Set(env.toLowerCase().split(/[\s,]+/).filter(isKeybinding)));
+}
+var isUpKey = (key, keybindings2 = []) => key.name === "up" || keybindings2.includes("vim") && key.name === "k" || keybindings2.includes("emacs") && key.ctrl && key.name === "p";
+var isDownKey = (key, keybindings2 = []) => key.name === "down" || keybindings2.includes("vim") && key.name === "j" || keybindings2.includes("emacs") && key.ctrl && key.name === "n";
+var isSpaceKey = (key) => key.name === "space";
+var isNumberKey = (key) => "1234567890".includes(key.name);
+var isEnterKey = (key) => key.name === "enter" || key.name === "return";
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/errors.js
+class AbortPromptError extends Error {
+  name = "AbortPromptError";
+  message = "Prompt was aborted";
+  constructor(options) {
+    super();
+    this.cause = options?.cause;
+  }
+}
+
+class CancelPromptError extends Error {
+  name = "CancelPromptError";
+  message = "Prompt was canceled";
+}
+
+class ExitPromptError extends Error {
+  name = "ExitPromptError";
+}
+
+class HookError extends Error {
+  name = "HookError";
+}
+
+class ValidationError extends Error {
+  name = "ValidationError";
+}
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/use-state.js
+import { AsyncResource as AsyncResource2 } from "node:async_hooks";
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/hook-engine.js
+import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
+var hookStorage = new AsyncLocalStorage;
+function createStore(rl) {
+  const store = {
+    rl,
+    hooks: [],
+    hooksCleanup: [],
+    hooksEffect: [],
+    index: 0,
+    handleChange() {}
+  };
+  return store;
+}
+function withHooks(rl, cb) {
+  const store = createStore(rl);
+  return hookStorage.run(store, () => {
+    function cycle(render) {
+      store.handleChange = () => {
+        store.index = 0;
+        render();
+      };
+      store.handleChange();
+    }
+    return cb(cycle);
   });
-  const includeOxc = await prompter.confirm("是否引入 Oxlint + Oxfmt？", true);
-  const projectLicense = await prompter.selectLicense();
-  const licenseHolder = projectLicense === "MIT" ? (await prompter.text("MIT 许可证权利人名称：")).trim() : undefined;
-  if (projectLicense === "MIT" && !licenseHolder) {
-    throw new Error("选择 MIT 时必须填写许可证权利人名称");
+}
+function getStore() {
+  const store = hookStorage.getStore();
+  if (!store) {
+    throw new HookError("[Inquirer] Hook functions can only be called from within a prompt");
   }
-  const selectedModules = resolveModuleSelection({
-    includeRecommended: false,
-    requested
+  return store;
+}
+function readline() {
+  return getStore().rl;
+}
+function withUpdates(fn) {
+  const wrapped = (...args) => {
+    const store = getStore();
+    let shouldUpdate = false;
+    const oldHandleChange = store.handleChange;
+    store.handleChange = () => {
+      shouldUpdate = true;
+    };
+    const returnValue = fn(...args);
+    if (shouldUpdate) {
+      oldHandleChange();
+    }
+    store.handleChange = oldHandleChange;
+    return returnValue;
+  };
+  return AsyncResource.bind(wrapped);
+}
+function withPointer(cb) {
+  const store = getStore();
+  const { index } = store;
+  const pointer = {
+    get() {
+      return store.hooks[index];
+    },
+    set(value) {
+      store.hooks[index] = value;
+    },
+    initialized: index in store.hooks
+  };
+  const returnValue = cb(pointer);
+  store.index++;
+  return returnValue;
+}
+function handleChange() {
+  getStore().handleChange();
+}
+var effectScheduler = {
+  queue(cb) {
+    const store = getStore();
+    const { index } = store;
+    store.hooksEffect.push(() => {
+      store.hooksCleanup[index]?.();
+      const cleanFn = cb(readline());
+      if (cleanFn != null && typeof cleanFn !== "function") {
+        throw new ValidationError("useEffect return value must be a cleanup function or nothing.");
+      }
+      store.hooksCleanup[index] = cleanFn;
+    });
+  },
+  run() {
+    const store = getStore();
+    withUpdates(() => {
+      store.hooksEffect.forEach((effect) => {
+        effect();
+      });
+      store.hooksEffect.length = 0;
+    })();
+  },
+  clearAll() {
+    const store = getStore();
+    store.hooksCleanup.forEach((cleanFn) => {
+      cleanFn?.();
+    });
+    store.hooksEffect.length = 0;
+    store.hooksCleanup.length = 0;
+  }
+};
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/use-state.js
+function isFactory(value) {
+  return typeof value === "function";
+}
+function useState(defaultValue) {
+  return withPointer((pointer) => {
+    const setState = AsyncResource2.bind(function setState2(newValue) {
+      if (pointer.get() !== newValue) {
+        pointer.set(newValue);
+        handleChange();
+      }
+    });
+    if (pointer.initialized) {
+      return [pointer.get(), setState];
+    }
+    const value = isFactory(defaultValue) ? defaultValue() : defaultValue;
+    pointer.set(value);
+    return [value, setState];
+  });
+}
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/use-effect.js
+function useEffect(cb, depArray) {
+  withPointer((pointer) => {
+    const oldDeps = pointer.get();
+    const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i) => !Object.is(dep, oldDeps[i]));
+    if (hasChanged) {
+      effectScheduler.queue(cb);
+    }
+    pointer.set(depArray);
   });
+}
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/theme.js
+import { styleText } from "node:util";
+
+// ../../node_modules/.bun/@inquirer+figures@2.0.7/node_modules/@inquirer/figures/dist/index.js
+import process2 from "node:process";
+function isUnicodeSupported() {
+  if (!process2.platform.startsWith("win")) {
+    return process2.env["TERM"] !== "linux";
+  }
+  return Boolean(process2.env["CI"]) || Boolean(process2.env["WT_SESSION"]) || Boolean(process2.env["TERMINUS_SUBLIME"]) || process2.env["ConEmuTask"] === "{cmd::Cmder}" || process2.env["TERM_PROGRAM"] === "Terminus-Sublime" || process2.env["TERM_PROGRAM"] === "vscode" || process2.env["TERM"] === "xterm-256color" || process2.env["TERM"] === "alacritty" || process2.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
+}
+var common = {
+  circleQuestionMark: "(?)",
+  questionMarkPrefix: "(?)",
+  square: "█",
+  squareDarkShade: "▓",
+  squareMediumShade: "▒",
+  squareLightShade: "░",
+  squareTop: "▀",
+  squareBottom: "▄",
+  squareLeft: "▌",
+  squareRight: "▐",
+  squareCenter: "■",
+  bullet: "●",
+  dot: "․",
+  ellipsis: "…",
+  pointerSmall: "›",
+  triangleUp: "▲",
+  triangleUpSmall: "▴",
+  triangleDown: "▼",
+  triangleDownSmall: "▾",
+  triangleLeftSmall: "◂",
+  triangleRightSmall: "▸",
+  home: "⌂",
+  heart: "♥",
+  musicNote: "♪",
+  musicNoteBeamed: "♫",
+  arrowUp: "↑",
+  arrowDown: "↓",
+  arrowLeft: "←",
+  arrowRight: "→",
+  arrowLeftRight: "↔",
+  arrowUpDown: "↕",
+  almostEqual: "≈",
+  notEqual: "≠",
+  lessOrEqual: "≤",
+  greaterOrEqual: "≥",
+  identical: "≡",
+  infinity: "∞",
+  subscriptZero: "₀",
+  subscriptOne: "₁",
+  subscriptTwo: "₂",
+  subscriptThree: "₃",
+  subscriptFour: "₄",
+  subscriptFive: "₅",
+  subscriptSix: "₆",
+  subscriptSeven: "₇",
+  subscriptEight: "₈",
+  subscriptNine: "₉",
+  oneHalf: "½",
+  oneThird: "⅓",
+  oneQuarter: "¼",
+  oneFifth: "⅕",
+  oneSixth: "⅙",
+  oneEighth: "⅛",
+  twoThirds: "⅔",
+  twoFifths: "⅖",
+  threeQuarters: "¾",
+  threeFifths: "⅗",
+  threeEighths: "⅜",
+  fourFifths: "⅘",
+  fiveSixths: "⅚",
+  fiveEighths: "⅝",
+  sevenEighths: "⅞",
+  line: "─",
+  lineBold: "━",
+  lineDouble: "═",
+  lineDashed0: "┄",
+  lineDashed1: "┅",
+  lineDashed2: "┈",
+  lineDashed3: "┉",
+  lineDashed4: "╌",
+  lineDashed5: "╍",
+  lineDashed6: "╴",
+  lineDashed7: "╶",
+  lineDashed8: "╸",
+  lineDashed9: "╺",
+  lineDashed10: "╼",
+  lineDashed11: "╾",
+  lineDashed12: "−",
+  lineDashed13: "–",
+  lineDashed14: "‐",
+  lineDashed15: "⁃",
+  lineVertical: "│",
+  lineVerticalBold: "┃",
+  lineVerticalDouble: "║",
+  lineVerticalDashed0: "┆",
+  lineVerticalDashed1: "┇",
+  lineVerticalDashed2: "┊",
+  lineVerticalDashed3: "┋",
+  lineVerticalDashed4: "╎",
+  lineVerticalDashed5: "╏",
+  lineVerticalDashed6: "╵",
+  lineVerticalDashed7: "╷",
+  lineVerticalDashed8: "╹",
+  lineVerticalDashed9: "╻",
+  lineVerticalDashed10: "╽",
+  lineVerticalDashed11: "╿",
+  lineDownLeft: "┐",
+  lineDownLeftArc: "╮",
+  lineDownBoldLeftBold: "┓",
+  lineDownBoldLeft: "┒",
+  lineDownLeftBold: "┑",
+  lineDownDoubleLeftDouble: "╗",
+  lineDownDoubleLeft: "╖",
+  lineDownLeftDouble: "╕",
+  lineDownRight: "┌",
+  lineDownRightArc: "╭",
+  lineDownBoldRightBold: "┏",
+  lineDownBoldRight: "┎",
+  lineDownRightBold: "┍",
+  lineDownDoubleRightDouble: "╔",
+  lineDownDoubleRight: "╓",
+  lineDownRightDouble: "╒",
+  lineUpLeft: "┘",
+  lineUpLeftArc: "╯",
+  lineUpBoldLeftBold: "┛",
+  lineUpBoldLeft: "┚",
+  lineUpLeftBold: "┙",
+  lineUpDoubleLeftDouble: "╝",
+  lineUpDoubleLeft: "╜",
+  lineUpLeftDouble: "╛",
+  lineUpRight: "└",
+  lineUpRightArc: "╰",
+  lineUpBoldRightBold: "┗",
+  lineUpBoldRight: "┖",
+  lineUpRightBold: "┕",
+  lineUpDoubleRightDouble: "╚",
+  lineUpDoubleRight: "╙",
+  lineUpRightDouble: "╘",
+  lineUpDownLeft: "┤",
+  lineUpBoldDownBoldLeftBold: "┫",
+  lineUpBoldDownBoldLeft: "┨",
+  lineUpDownLeftBold: "┥",
+  lineUpBoldDownLeftBold: "┩",
+  lineUpDownBoldLeftBold: "┪",
+  lineUpDownBoldLeft: "┧",
+  lineUpBoldDownLeft: "┦",
+  lineUpDoubleDownDoubleLeftDouble: "╣",
+  lineUpDoubleDownDoubleLeft: "╢",
+  lineUpDownLeftDouble: "╡",
+  lineUpDownRight: "├",
+  lineUpBoldDownBoldRightBold: "┣",
+  lineUpBoldDownBoldRight: "┠",
+  lineUpDownRightBold: "┝",
+  lineUpBoldDownRightBold: "┡",
+  lineUpDownBoldRightBold: "┢",
+  lineUpDownBoldRight: "┟",
+  lineUpBoldDownRight: "┞",
+  lineUpDoubleDownDoubleRightDouble: "╠",
+  lineUpDoubleDownDoubleRight: "╟",
+  lineUpDownRightDouble: "╞",
+  lineDownLeftRight: "┬",
+  lineDownBoldLeftBoldRightBold: "┳",
+  lineDownLeftBoldRightBold: "┯",
+  lineDownBoldLeftRight: "┰",
+  lineDownBoldLeftBoldRight: "┱",
+  lineDownBoldLeftRightBold: "┲",
+  lineDownLeftRightBold: "┮",
+  lineDownLeftBoldRight: "┭",
+  lineDownDoubleLeftDoubleRightDouble: "╦",
+  lineDownDoubleLeftRight: "╥",
+  lineDownLeftDoubleRightDouble: "╤",
+  lineUpLeftRight: "┴",
+  lineUpBoldLeftBoldRightBold: "┻",
+  lineUpLeftBoldRightBold: "┷",
+  lineUpBoldLeftRight: "┸",
+  lineUpBoldLeftBoldRight: "┹",
+  lineUpBoldLeftRightBold: "┺",
+  lineUpLeftRightBold: "┶",
+  lineUpLeftBoldRight: "┵",
+  lineUpDoubleLeftDoubleRightDouble: "╩",
+  lineUpDoubleLeftRight: "╨",
+  lineUpLeftDoubleRightDouble: "╧",
+  lineUpDownLeftRight: "┼",
+  lineUpBoldDownBoldLeftBoldRightBold: "╋",
+  lineUpDownBoldLeftBoldRightBold: "╈",
+  lineUpBoldDownLeftBoldRightBold: "╇",
+  lineUpBoldDownBoldLeftRightBold: "╊",
+  lineUpBoldDownBoldLeftBoldRight: "╉",
+  lineUpBoldDownLeftRight: "╀",
+  lineUpDownBoldLeftRight: "╁",
+  lineUpDownLeftBoldRight: "┽",
+  lineUpDownLeftRightBold: "┾",
+  lineUpBoldDownBoldLeftRight: "╂",
+  lineUpDownLeftBoldRightBold: "┿",
+  lineUpBoldDownLeftBoldRight: "╃",
+  lineUpBoldDownLeftRightBold: "╄",
+  lineUpDownBoldLeftBoldRight: "╅",
+  lineUpDownBoldLeftRightBold: "╆",
+  lineUpDoubleDownDoubleLeftDoubleRightDouble: "╬",
+  lineUpDoubleDownDoubleLeftRight: "╫",
+  lineUpDownLeftDoubleRightDouble: "╪",
+  lineCross: "╳",
+  lineBackslash: "╲",
+  lineSlash: "╱"
+};
+var specialMainSymbols = {
+  tick: "✔",
+  info: "ℹ",
+  warning: "⚠",
+  cross: "✘",
+  squareSmall: "◻",
+  squareSmallFilled: "◼",
+  circle: "◯",
+  circleFilled: "◉",
+  circleDotted: "◌",
+  circleDouble: "◎",
+  circleCircle: "ⓞ",
+  circleCross: "ⓧ",
+  circlePipe: "Ⓘ",
+  radioOn: "◉",
+  radioOff: "◯",
+  checkboxOn: "☒",
+  checkboxOff: "☐",
+  checkboxCircleOn: "ⓧ",
+  checkboxCircleOff: "Ⓘ",
+  pointer: "❯",
+  triangleUpOutline: "△",
+  triangleLeft: "◀",
+  triangleRight: "▶",
+  lozenge: "◆",
+  lozengeOutline: "◇",
+  hamburger: "☰",
+  smiley: "㋡",
+  mustache: "෴",
+  star: "★",
+  play: "▶",
+  nodejs: "⬢",
+  oneSeventh: "⅐",
+  oneNinth: "⅑",
+  oneTenth: "⅒"
+};
+var specialFallbackSymbols = {
+  tick: "√",
+  info: "i",
+  warning: "‼",
+  cross: "×",
+  squareSmall: "□",
+  squareSmallFilled: "■",
+  circle: "( )",
+  circleFilled: "(*)",
+  circleDotted: "( )",
+  circleDouble: "( )",
+  circleCircle: "(○)",
+  circleCross: "(×)",
+  circlePipe: "(│)",
+  radioOn: "(*)",
+  radioOff: "( )",
+  checkboxOn: "[×]",
+  checkboxOff: "[ ]",
+  checkboxCircleOn: "(×)",
+  checkboxCircleOff: "( )",
+  pointer: ">",
+  triangleUpOutline: "∆",
+  triangleLeft: "◄",
+  triangleRight: "►",
+  lozenge: "♦",
+  lozengeOutline: "◊",
+  hamburger: "≡",
+  smiley: "☺",
+  mustache: "┌─┐",
+  star: "✶",
+  play: "►",
+  nodejs: "♦",
+  oneSeventh: "1/7",
+  oneNinth: "1/9",
+  oneTenth: "1/10"
+};
+var mainSymbols = {
+  ...common,
+  ...specialMainSymbols
+};
+var fallbackSymbols = {
+  ...common,
+  ...specialFallbackSymbols
+};
+var shouldUseMain = isUnicodeSupported();
+var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+var dist_default = figures;
+var replacements = Object.entries(specialMainSymbols);
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/theme.js
+var defaultTheme = {
+  prefix: {
+    idle: styleText("blue", "?"),
+    done: styleText("green", dist_default.tick)
+  },
+  spinner: {
+    interval: 80,
+    frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"].map((frame) => styleText("yellow", frame))
+  },
+  keybindings: [],
+  style: {
+    answer: (text) => styleText("cyan", text),
+    message: (text) => styleText("bold", text),
+    error: (text) => styleText("red", `> ${text}`),
+    defaultAnswer: (text) => styleText("dim", `(${text})`),
+    help: (text) => styleText("dim", text),
+    highlight: (text) => styleText("cyan", text),
+    key: (text) => styleText("cyan", styleText("bold", `<${text}>`))
+  }
+};
+function getDefaultTheme() {
   return {
-    ...options,
-    selectedModules,
-    includeExample: selectedModules.includes("work-order"),
-    includeOxc,
-    projectLicense,
-    licenseHolder,
-    interactive: false
+    ...defaultTheme,
+    keybindings: getDefaultKeybindings()
   };
 }
-function terminalPrompter() {
-  const question = async (message) => {
-    const readline = createInterface({ input: stdin, output: stdout });
-    try {
-      return await readline.question(message);
-    } finally {
-      readline.close();
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/make-theme.js
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  let proto = value;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+function deepMerge(...objects) {
+  const output = {};
+  for (const obj of objects) {
+    for (const [key, value] of Object.entries(obj)) {
+      const prevValue = output[key];
+      output[key] = isPlainObject(prevValue) && isPlainObject(value) ? deepMerge(prevValue, value) : value;
+    }
+  }
+  return output;
+}
+function makeTheme(...themes) {
+  const themesToMerge = [
+    getDefaultTheme(),
+    ...themes.filter((theme) => theme != null)
+  ];
+  return deepMerge(...themesToMerge);
+}
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/use-prefix.js
+function usePrefix({ status = "idle", theme }) {
+  const [showLoader, setShowLoader] = useState(false);
+  const [tick, setTick] = useState(0);
+  const { prefix, spinner } = makeTheme(theme);
+  useEffect(() => {
+    if (status === "loading") {
+      let tickInterval;
+      let inc = -1;
+      const delayTimeout = setTimeout(() => {
+        setShowLoader(true);
+        tickInterval = setInterval(() => {
+          inc = inc + 1;
+          setTick(inc % spinner.frames.length);
+        }, spinner.interval);
+      }, 300);
+      return () => {
+        clearTimeout(delayTimeout);
+        clearInterval(tickInterval);
+      };
+    } else {
+      setShowLoader(false);
     }
+  }, [status]);
+  if (showLoader) {
+    return spinner.frames[tick];
+  }
+  const iconName = status === "loading" ? "idle" : status;
+  return typeof prefix === "string" ? prefix : prefix[iconName] ?? prefix["idle"];
+}
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/use-memo.js
+function useMemo(fn, dependencies) {
+  return withPointer((pointer) => {
+    const prev = pointer.get();
+    if (!prev || prev.dependencies.length !== dependencies.length || prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
+      const value = fn();
+      pointer.set({ value, dependencies });
+      return value;
+    }
+    return prev.value;
+  });
+}
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/use-ref.js
+function useRef(val) {
+  return useState({ current: val })[0];
+}
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/use-keypress.js
+function useKeypress(userHandler) {
+  const signal = useRef(userHandler);
+  signal.current = userHandler;
+  useEffect((rl) => {
+    let ignore = false;
+    const handler = withUpdates((_input, event) => {
+      if (ignore)
+        return;
+      signal.current(event, rl);
+    });
+    rl.input.on("keypress", handler);
+    return () => {
+      ignore = true;
+      rl.input.removeListener("keypress", handler);
+    };
+  }, []);
+}
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/utils.js
+var import_cli_width = __toESM(require_cli_width(), 1);
+
+// ../../node_modules/.bun/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
   };
-  return {
-    async selectModules({ choices, defaults }) {
-      stdout.write(`
-请选择要生成的平台模块（逗号分隔编号，直接回车采用推荐项）：
-`);
-      choices.forEach((choice, index) => {
-        const checked = defaults.includes(choice.value) ? "x" : " ";
-        stdout.write(`  ${index + 1}. [${checked}] ${choice.label} — ${choice.hint}
-`);
-      });
-      const answer = (await question("> ")).trim();
-      if (!answer)
-        return defaults;
-      const indexes = answer.split(",").map((part) => Number(part.trim()) - 1);
-      if (indexes.some((index) => !Number.isSafeInteger(index) || !choices[index])) {
-        throw new Error("模块选择包含无效编号");
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// ../../node_modules/.bun/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer:
+    while (true) {
+      if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+        lengthExtra = 0;
+        for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+          const codePoint = char.codePointAt(0) || 0;
+          if (isFullWidth(codePoint)) {
+            widthExtra = FULL_WIDTH_WIDTH;
+          } else if (isWideNotCJKTNotEmoji(codePoint)) {
+            widthExtra = WIDE_WIDTH;
+          } else {
+            widthExtra = REGULAR_WIDTH;
+          }
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          lengthExtra += char.length;
+          width += widthExtra;
+        }
+        unmatchedStart = unmatchedEnd = 0;
       }
-      return [...new Set(indexes.map((index) => choices[index].value))];
-    },
-    async confirm(message, defaultValue) {
-      const hint = defaultValue ? "Y/n" : "y/N";
-      const answer = (await question(`${message} (${hint}) `)).trim().toLowerCase();
-      if (!answer)
-        return defaultValue;
-      return answer === "y" || answer === "yes";
-    },
-    async selectLicense() {
-      const answer = (await question(`项目法律许可证：1. UNLICENSED（默认） 2. MIT 3. Apache-2.0
-> `)).trim();
-      if (!answer || answer === "1")
-        return "UNLICENSED";
-      if (answer === "2")
-        return "MIT";
-      if (answer === "3")
-        return "Apache-2.0";
-      throw new Error("许可证选择包含无效编号");
-    },
-    text(message) {
-      return question(message);
+      if (index >= length) {
+        break outer;
+      }
+      for (let i = 0, l = PARSE_BLOCKS.length;i < l; i++) {
+        const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+        BLOCK_RE.lastIndex = index;
+        if (BLOCK_RE.test(input)) {
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+          widthExtra = lengthExtra * BLOCK_WIDTH;
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          width += widthExtra;
+          unmatchedStart = indexPrev;
+          unmatchedEnd = index;
+          index = indexPrev = BLOCK_RE.lastIndex;
+          continue outer;
+        }
+      }
+      index += 1;
     }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
   };
-}
+};
+var dist_default2 = getStringTruncatedWidth;
 
-// src/cli.ts
-async function main() {
-  const options = parseArguments(process.argv.slice(2));
+// ../../node_modules/.bun/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default2(input, NO_TRUNCATION2, options).width;
+};
+var dist_default3 = fastStringWidth;
+
+// ../../node_modules/.bun/fast-wrap-ansi@0.2.2/node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "›";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === undefined ? 0 : dist_default3(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default3(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default3(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0;index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default3(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default3(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default3(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join(`
+`);
+  let inSurrogate = false;
+  for (let i = 0;i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? undefined : code;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
+`);
+}
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/utils.js
+function breakLines(content, width) {
+  return content.split(`
+`).flatMap((line) => wrapAnsi(line, width, { trim: false, wordWrap: false }).split(`
+`).map((str) => str.trimEnd())).join(`
+`);
+}
+function readlineWidth() {
+  return import_cli_width.default({ defaultWidth: 80, output: readline().output });
+}
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js
+function usePointerPosition({ active, renderedItems, pageSize, loop }) {
+  const state = useRef({
+    lastPointer: active,
+    lastActive: undefined
+  });
+  const { lastPointer, lastActive } = state.current;
+  const middle = Math.floor(pageSize / 2);
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const defaultPointerPosition = renderedItems.slice(0, active).reduce((acc, item) => acc + item.length, 0);
+  let pointer = defaultPointerPosition;
+  if (renderedLength > pageSize) {
+    if (loop) {
+      pointer = lastPointer;
+      if (lastActive != null && lastActive < active && active - lastActive < pageSize) {
+        pointer = Math.min(middle, Math.abs(active - lastActive) === 1 ? Math.min(lastPointer + (renderedItems[lastActive]?.length ?? 0), Math.max(defaultPointerPosition, lastPointer)) : lastPointer + active - lastActive);
+      }
+    } else {
+      const spaceUnderActive = renderedItems.slice(active).reduce((acc, item) => acc + item.length, 0);
+      pointer = spaceUnderActive < pageSize - middle ? pageSize - spaceUnderActive : Math.min(defaultPointerPosition, middle);
+    }
+  }
+  state.current.lastPointer = pointer;
+  state.current.lastActive = active;
+  return pointer;
+}
+function usePagination({ items, active, renderItem, pageSize, loop = true }) {
+  const width = readlineWidth();
+  const bound = (num) => (num % items.length + items.length) % items.length;
+  const renderedItems = items.map((item, index) => {
+    if (item == null)
+      return [];
+    return breakLines(renderItem({ item, index, isActive: index === active }), width).split(`
+`);
+  });
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const renderItemAtIndex = (index) => renderedItems[index] ?? [];
+  const pointer = usePointerPosition({ active, renderedItems, pageSize, loop });
+  const activeItem = renderItemAtIndex(active).slice(0, pageSize);
+  const activeItemPosition = pointer + activeItem.length <= pageSize ? pointer : pageSize - activeItem.length;
+  const pageBuffer = Array.from({ length: pageSize });
+  pageBuffer.splice(activeItemPosition, activeItem.length, ...activeItem);
+  const itemVisited = new Set([active]);
+  let bufferPointer = activeItemPosition + activeItem.length;
+  let itemPointer = bound(active + 1);
+  while (bufferPointer < pageSize && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer > active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(0, pageSize - bufferPointer);
+    pageBuffer.splice(bufferPointer, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer += linesToAdd.length;
+    itemPointer = bound(itemPointer + 1);
+  }
+  bufferPointer = activeItemPosition - 1;
+  itemPointer = bound(active - 1);
+  while (bufferPointer >= 0 && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer < active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(Math.max(0, lines.length - bufferPointer - 1));
+    pageBuffer.splice(bufferPointer - linesToAdd.length + 1, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer -= linesToAdd.length;
+    itemPointer = bound(itemPointer - 1);
+  }
+  return pageBuffer.filter((line) => typeof line === "string").join(`
+`);
+}
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/create-prompt.js
+var import_mute_stream = __toESM(require_lib(), 1);
+import * as readline2 from "node:readline";
+import { AsyncResource as AsyncResource3 } from "node:async_hooks";
+
+// ../../node_modules/.bun/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+  signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+}
+if (process.platform === "linux") {
+  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+// ../../node_modules/.bun/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+var processOk = (process3) => !!process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+var kExitEmitter = Symbol.for("signal-exit emitter");
+var global = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+
+class Emitter {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
+    }
+    ObjectDefineProperty(global, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+}
+
+class SignalExitBase {
+}
+var signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+};
+
+class SignalExitFallback extends SignalExitBase {
+  onExit() {
+    return () => {};
+  }
+  load() {}
+  unload() {}
+}
+
+class SignalExit extends SignalExitBase {
+  #hupSig = process3.platform === "win32" ? "SIGINT" : "SIGHUP";
+  #emitter = new Emitter;
+  #process;
+  #originalProcessEmit;
+  #originalProcessReallyExit;
+  #sigListeners = {};
+  #loaded = false;
+  constructor(process3) {
+    super();
+    this.#process = process3;
+    this.#sigListeners = {};
+    for (const sig of signals) {
+      this.#sigListeners[sig] = () => {
+        const listeners = this.#process.listeners(sig);
+        let { count } = this.#emitter;
+        const p = process3;
+        if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+          count += p.__signal_exit_emitter__.count;
+        }
+        if (listeners.length === count) {
+          this.unload();
+          const ret = this.#emitter.emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? this.#hupSig : sig;
+          if (!ret)
+            process3.kill(process3.pid, s);
+        }
+      };
+    }
+    this.#originalProcessReallyExit = process3.reallyExit;
+    this.#originalProcessEmit = process3.emit;
+  }
+  onExit(cb, opts) {
+    if (!processOk(this.#process)) {
+      return () => {};
+    }
+    if (this.#loaded === false) {
+      this.load();
+    }
+    const ev = opts?.alwaysLast ? "afterExit" : "exit";
+    this.#emitter.on(ev, cb);
+    return () => {
+      this.#emitter.removeListener(ev, cb);
+      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+        this.unload();
+      }
+    };
+  }
+  load() {
+    if (this.#loaded) {
+      return;
+    }
+    this.#loaded = true;
+    this.#emitter.count += 1;
+    for (const sig of signals) {
+      try {
+        const fn = this.#sigListeners[sig];
+        if (fn)
+          this.#process.on(sig, fn);
+      } catch (_) {}
+    }
+    this.#process.emit = (ev, ...a) => {
+      return this.#processEmit(ev, ...a);
+    };
+    this.#process.reallyExit = (code) => {
+      return this.#processReallyExit(code);
+    };
+  }
+  unload() {
+    if (!this.#loaded) {
+      return;
+    }
+    this.#loaded = false;
+    signals.forEach((sig) => {
+      const listener = this.#sigListeners[sig];
+      if (!listener) {
+        throw new Error("Listener not defined for signal: " + sig);
+      }
+      try {
+        this.#process.removeListener(sig, listener);
+      } catch (_) {}
+    });
+    this.#process.emit = this.#originalProcessEmit;
+    this.#process.reallyExit = this.#originalProcessReallyExit;
+    this.#emitter.count -= 1;
+  }
+  #processReallyExit(code) {
+    if (!processOk(this.#process)) {
+      return 0;
+    }
+    this.#process.exitCode = code || 0;
+    this.#emitter.emit("exit", this.#process.exitCode, null);
+    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+  }
+  #processEmit(ev, ...args) {
+    const og = this.#originalProcessEmit;
+    if (ev === "exit" && processOk(this.#process)) {
+      if (typeof args[0] === "number") {
+        this.#process.exitCode = args[0];
+      }
+      const ret = og.call(this.#process, ev, ...args);
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return ret;
+    } else {
+      return og.call(this.#process, ev, ...args);
+    }
+  }
+}
+var process3 = globalThis.process;
+var {
+  onExit,
+  load,
+  unload
+} = signalExitWrap(processOk(process3) ? new SignalExit(process3) : new SignalExitFallback);
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/screen-manager.js
+import { stripVTControlCharacters } from "node:util";
+
+// ../../node_modules/.bun/@inquirer+ansi@2.0.7/node_modules/@inquirer/ansi/dist/index.js
+var ESC2 = "\x1B[";
+var cursorLeft = ESC2 + "G";
+var cursorHide = ESC2 + "?25l";
+var cursorShow = ESC2 + "?25h";
+var cursorUp = (rows = 1) => rows > 0 ? `${ESC2}${rows}A` : "";
+var cursorDown = (rows = 1) => rows > 0 ? `${ESC2}${rows}B` : "";
+var cursorTo = (x, y) => {
+  if (typeof y === "number" && !Number.isNaN(y)) {
+    return `${ESC2}${y + 1};${x + 1}H`;
+  }
+  return `${ESC2}${x + 1}G`;
+};
+var eraseLine = ESC2 + "2K";
+var eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : "";
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/screen-manager.js
+var height = (content) => content.split(`
+`).length;
+var lastLine = (content) => content.split(`
+`).pop() ?? "";
+
+class ScreenManager {
+  height = 0;
+  extraLinesUnderPrompt = 0;
+  cursorPos;
+  rl;
+  constructor(rl) {
+    this.rl = rl;
+    this.cursorPos = rl.getCursorPos();
+  }
+  write(content) {
+    this.rl.output.unmute();
+    this.rl.output.write(content);
+    this.rl.output.mute();
+  }
+  render(content, bottomContent = "") {
+    const promptLine = lastLine(content);
+    const rawPromptLine = stripVTControlCharacters(promptLine);
+    let prompt = rawPromptLine;
+    if (this.rl.line.length > 0) {
+      prompt = prompt.slice(0, -this.rl.line.length);
+    }
+    this.rl.setPrompt(prompt);
+    this.cursorPos = this.rl.getCursorPos();
+    const width = readlineWidth();
+    content = breakLines(content, width);
+    bottomContent = breakLines(bottomContent, width);
+    if (rawPromptLine.length % width === 0) {
+      content += `
+`;
+    }
+    let output = content + (bottomContent ? `
+` + bottomContent : "");
+    const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+    const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+    if (bottomContentHeight > 0)
+      output += cursorUp(bottomContentHeight);
+    output += cursorTo(this.cursorPos.cols);
+    this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
+    this.extraLinesUnderPrompt = bottomContentHeight;
+    this.height = height(output);
+  }
+  checkCursorPos() {
+    const cursorPos = this.rl.getCursorPos();
+    if (cursorPos.cols !== this.cursorPos.cols) {
+      this.write(cursorTo(cursorPos.cols));
+      this.cursorPos = cursorPos;
+    }
+  }
+  done({ clearContent }) {
+    this.rl.setPrompt("");
+    let output = cursorDown(this.extraLinesUnderPrompt);
+    output += clearContent ? eraseLines(this.height) : `
+`;
+    output += cursorLeft;
+    output += cursorShow;
+    this.write(output);
+    this.rl.close();
+  }
+}
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/promise-polyfill.js
+class PromisePolyfill extends Promise {
+  static withResolver() {
+    let resolve4;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve4 = res;
+      reject = rej;
+    });
+    return { promise, resolve: resolve4, reject };
+  }
+}
+
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/create-prompt.js
+import path from "node:path";
+var nativeSetImmediate = globalThis.setImmediate;
+function getCallSites() {
+  const savedPrepareStackTrace = Error.prepareStackTrace;
+  let result = [];
+  try {
+    Error.prepareStackTrace = (_, callSites) => {
+      const callSitesWithoutCurrent = callSites.slice(1);
+      result = callSitesWithoutCurrent;
+      return callSitesWithoutCurrent;
+    };
+    new Error().stack;
+  } catch {
+    return result;
+  }
+  Error.prepareStackTrace = savedPrepareStackTrace;
+  return result;
+}
+function createPrompt(view) {
+  const callSites = getCallSites();
+  const prompt = (config, context = {}) => {
+    const { input = process.stdin, signal } = context;
+    const cleanups = new Set;
+    const output = new import_mute_stream.default;
+    output.pipe(context.output ?? process.stdout);
+    const rl = readline2.createInterface({
+      terminal: true,
+      input,
+      output
+    });
+    output.mute();
+    const screen = new ScreenManager(rl);
+    const { promise, resolve: resolve4, reject } = PromisePolyfill.withResolver();
+    const cancel = () => reject(new CancelPromptError);
+    if (signal) {
+      const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
+      if (signal.aborted) {
+        abort();
+        return Object.assign(promise, { cancel });
+      }
+      signal.addEventListener("abort", abort);
+      cleanups.add(() => signal.removeEventListener("abort", abort));
+    }
+    cleanups.add(onExit((code, signal2) => {
+      reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal2}`));
+    }));
+    const sigint = () => reject(new ExitPromptError(`User force closed the prompt with SIGINT`));
+    rl.on("SIGINT", sigint);
+    cleanups.add(() => rl.removeListener("SIGINT", sigint));
+    return withHooks(rl, (cycle) => {
+      const hooksCleanup = AsyncResource3.bind(() => effectScheduler.clearAll());
+      rl.on("close", hooksCleanup);
+      cleanups.add(() => rl.removeListener("close", hooksCleanup));
+      const startCycle = () => {
+        const checkCursorPos = () => screen.checkCursorPos();
+        rl.input.on("keypress", checkCursorPos);
+        cleanups.add(() => rl.input.removeListener("keypress", checkCursorPos));
+        let pendingDone = null;
+        cycle(() => {
+          let effectsSettled = false;
+          try {
+            const nextView = view(config, (value) => {
+              if (effectsSettled) {
+                resolve4(value);
+              } else {
+                pendingDone = { value };
+              }
+            });
+            if (nextView === undefined) {
+              let callerFilename = callSites[1]?.getFileName();
+              if (callerFilename && !callerFilename.startsWith("file://")) {
+                callerFilename = path.resolve(callerFilename);
+              }
+              throw new Error(`Prompt functions must return a string.
+    at ${callerFilename}`);
+            }
+            const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
+            screen.render(content, bottomContent);
+            effectScheduler.run();
+          } catch (error) {
+            reject(error);
+          }
+          effectsSettled = true;
+          if (pendingDone !== null) {
+            const { value } = pendingDone;
+            pendingDone = null;
+            resolve4(value);
+          }
+        });
+      };
+      if ("readableFlowing" in input) {
+        nativeSetImmediate(startCycle);
+      } else {
+        startCycle();
+      }
+      return Object.assign(promise.then((answer) => {
+        effectScheduler.clearAll();
+        return answer;
+      }, (error) => {
+        effectScheduler.clearAll();
+        throw error;
+      }).finally(() => {
+        cleanups.forEach((cleanup) => cleanup());
+        screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+        output.end();
+      }).then(() => promise), { cancel });
+    });
+  };
+  return prompt;
+}
+// ../../node_modules/.bun/@inquirer+core@11.2.1+e154a6929a67600d/node_modules/@inquirer/core/dist/lib/Separator.js
+import { styleText as styleText2 } from "node:util";
+class Separator {
+  separator = styleText2("dim", Array.from({ length: 15 }).join(dist_default.line));
+  type = "separator";
+  constructor(separator) {
+    if (separator) {
+      this.separator = separator;
+    }
+  }
+  static isSeparator(choice) {
+    return Boolean(choice && typeof choice === "object" && "type" in choice && choice.type === "separator");
+  }
+}
+// ../../node_modules/.bun/@inquirer+checkbox@5.2.1+e154a6929a67600d/node_modules/@inquirer/checkbox/dist/index.js
+import { styleText as styleText3 } from "node:util";
+var checkboxTheme = {
+  icon: {
+    checked: styleText3("green", dist_default.circleFilled),
+    unchecked: dist_default.circle,
+    cursor: dist_default.pointer,
+    disabledChecked: styleText3("green", dist_default.circleDouble),
+    disabledUnchecked: "-"
+  },
+  style: {
+    disabled: (text) => styleText3("dim", text),
+    renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+    description: (text) => styleText3("cyan", text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${styleText3("bold", key)} ${styleText3("dim", action)}`).join(styleText3("dim", " • "))
+  },
+  i18n: { disabledError: "This option is disabled and cannot be toggled." }
+};
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable(item) {
+  return !Separator.isSeparator(item);
+}
+function isChecked(item) {
+  return !Separator.isSeparator(item) && item.checked;
+}
+function toggle(item) {
+  return isSelectable(item) ? { ...item, checked: !item.checked } : item;
+}
+function check(checked) {
+  return function(item) {
+    return isSelectable(item) ? { ...item, checked } : item;
+  };
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice))
+      return choice;
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
+      return {
+        value: choice,
+        name: name2,
+        short: name2,
+        checkedName: name2,
+        disabled: false,
+        checked: false
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      checkedName: choice.checkedName ?? name,
+      disabled: choice.disabled ?? false,
+      checked: choice.checked ?? false
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+var dist_default4 = createPrompt((config, done) => {
+  const { pageSize = 7, loop = true, required, validate = () => true } = config;
+  const shortcuts = { all: "a", invert: "i", ...config.shortcuts };
+  const theme = makeTheme(checkboxTheme, config.theme);
+  const { keybindings: keybindings2 } = theme;
+  const [status, setStatus] = useState("idle");
+  const prefix = usePrefix({ status, theme });
+  const [items, setItems] = useState(normalizeChoices(config.choices));
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isNavigable);
+    const last = items.findLastIndex(isNavigable);
+    if (first === -1) {
+      throw new ValidationError("[checkbox prompt] No selectable choices. All choices are disabled.");
+    }
+    return { first, last };
+  }, [items]);
+  const [active, setActive] = useState(bounds.first);
+  const [errorMsg, setError] = useState();
+  useKeypress(async (key) => {
+    if (isEnterKey(key)) {
+      const selection = items.filter(isChecked);
+      const isValid = await validate([...selection]);
+      if (required && !selection.length) {
+        setError("At least one choice must be selected");
+      } else if (isValid === true) {
+        setStatus("done");
+        done(selection.map((choice) => choice.value));
+      } else {
+        setError(isValid || "You must select a valid value");
+      }
+    } else if (isUpKey(key, keybindings2) || isDownKey(key, keybindings2)) {
+      if (errorMsg) {
+        setError(undefined);
+      }
+      if (loop || isUpKey(key, keybindings2) && active !== bounds.first || isDownKey(key, keybindings2) && active !== bounds.last) {
+        const offset = isUpKey(key, keybindings2) ? -1 : 1;
+        let next = active;
+        do {
+          next = (next + offset + items.length) % items.length;
+        } while (!isNavigable(items[next]));
+        setActive(next);
+      }
+    } else if (isSpaceKey(key)) {
+      const activeItem = items[active];
+      if (activeItem && !Separator.isSeparator(activeItem)) {
+        if (activeItem.disabled) {
+          setError(theme.i18n.disabledError);
+        } else {
+          setError(undefined);
+          setItems(items.map((choice, i) => i === active ? toggle(choice) : choice));
+        }
+      }
+    } else if (key.name === shortcuts.all) {
+      const selectAll = items.some((choice) => isSelectable(choice) && !choice.checked);
+      setItems(items.map(check(selectAll)));
+    } else if (key.name === shortcuts.invert) {
+      setItems(items.map(toggle));
+    } else if (isNumberKey(key)) {
+      const selectedIndex = Number(key.name) - 1;
+      let selectableIndex = -1;
+      const position = items.findIndex((item) => {
+        if (Separator.isSeparator(item))
+          return false;
+        selectableIndex++;
+        return selectableIndex === selectedIndex;
+      });
+      const selectedItem = items[position];
+      if (selectedItem && isSelectable(selectedItem)) {
+        setActive(position);
+        setItems(items.map((choice, i) => i === position ? toggle(choice) : choice));
+      }
+    }
+  });
+  const message = theme.style.message(config.message, status);
+  let description;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive }) {
+      if (Separator.isSeparator(item)) {
+        return ` ${item.separator}`;
+      }
+      const cursor = isActive ? theme.icon.cursor : " ";
+      if (item.disabled) {
+        const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+        const checkbox2 = item.checked ? theme.icon.disabledChecked : theme.icon.disabledUnchecked;
+        return theme.style.disabled(`${cursor}${checkbox2} ${item.name} ${disabledLabel}`);
+      }
+      if (isActive) {
+        description = item.description;
+      }
+      const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+      const name = item.checked ? item.checkedName : item.name;
+      const color = isActive ? theme.style.highlight : (x) => x;
+      return color(`${cursor}${checkbox} ${name}`);
+    },
+    pageSize,
+    loop
+  });
+  if (status === "done") {
+    const selection = items.filter(isChecked);
+    const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+    return [prefix, message, answer].filter(Boolean).join(" ");
+  }
+  const keys = [
+    ["↑↓", "navigate"],
+    ["space", "select"]
+  ];
+  if (shortcuts.all)
+    keys.push([shortcuts.all, "all"]);
+  if (shortcuts.invert)
+    keys.push([shortcuts.invert, "invert"]);
+  keys.push(["⏎", "submit"]);
+  const helpLine = theme.style.keysHelpTip(keys);
+  const lines = [
+    [prefix, message].filter(Boolean).join(" "),
+    page,
+    " ",
+    description ? theme.style.description(description) : "",
+    errorMsg ? theme.style.error(errorMsg) : "",
+    helpLine
+  ].filter(Boolean).join(`
+`).trimEnd();
+  return `${lines}${cursorHide}`;
+});
+
+// src/interactive-selection.ts
+var oxcChoiceKey = "toolchain.oxc";
+async function applyInteractiveSelection(options, prompter = terminalPrompter()) {
+  if (!options.interactive)
+    return options;
+  const optional = moduleDistributionCatalog.filter(({ name }) => !requiredModuleNames.includes(name));
+  const requested = await prompter.selectGenerationChoices({
+    choices: [
+      ...optional.map(({ name, label, description, selection }) => ({
+        value: name,
+        label: `${label}（${sentenceWithoutStop(description)}）`,
+        hint: selection === "recommended" ? "推荐，默认选中" : "可选模块"
+      })),
+      {
+        value: oxcChoiceKey,
+        label: "Oxc 代码质量（Oxlint、Oxfmt 与提交格式化）",
+        hint: "可选基础设施，默认选中"
+      }
+    ],
+    defaults: [...recommendedModuleNames, oxcChoiceKey]
+  });
+  const includeOxc = requested.includes(oxcChoiceKey);
+  const projectLicense = await prompter.selectLicense();
+  const licenseHolder = projectLicense === "MIT" ? (await prompter.text("MIT 许可证权利人名称：")).trim() : undefined;
+  if (projectLicense === "MIT" && !licenseHolder) {
+    throw new Error("选择 MIT 时必须填写许可证权利人名称");
+  }
+  const selectedModules = resolveModuleSelection({
+    includeRecommended: false,
+    requested: requested.filter((value) => value !== oxcChoiceKey)
+  });
+  return {
+    ...options,
+    selectedModules,
+    includeExample: selectedModules.includes("work-order"),
+    includeOxc,
+    projectLicense,
+    licenseHolder,
+    interactive: false
+  };
+}
+function terminalPrompter() {
+  const question = async (message) => {
+    const readline3 = createInterface2({ input: stdin, output: stdout });
+    try {
+      return await readline3.question(message);
+    } finally {
+      readline3.close();
+    }
+  };
+  return {
+    async selectGenerationChoices({ choices, defaults }) {
+      return dist_default4({
+        message: "请选择要生成的平台模块和基础设施",
+        choices: choices.map((choice) => ({
+          value: choice.value,
+          name: choice.label,
+          description: choice.hint,
+          checked: defaults.includes(choice.value)
+        })),
+        pageSize: choices.length,
+        loop: false,
+        shortcuts: { all: null, invert: null },
+        theme: {
+          style: {
+            keysHelpTip: () => "↑/↓ 切换 · 空格 选中或取消 · 回车 提交"
+          }
+        }
+      });
+    },
+    async selectLicense() {
+      const answer = (await question(`项目法律许可证：1. UNLICENSED（默认） 2. MIT 3. Apache-2.0
+> `)).trim();
+      if (!answer || answer === "1")
+        return "UNLICENSED";
+      if (answer === "2")
+        return "MIT";
+      if (answer === "3")
+        return "Apache-2.0";
+      throw new Error("许可证选择包含无效编号");
+    },
+    text(message) {
+      return question(message);
+    }
+  };
+}
+function sentenceWithoutStop(value) {
+  return value.replace(/[。.]$/, "");
+}
+
+// src/update/cli.ts
+import { rm as rm8 } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+
+// src/update/doctor.ts
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+
+// src/update/process.ts
+import { spawn as spawn3 } from "node:child_process";
+async function captureProcess(command, args, cwd, inherit = false) {
+  return await new Promise((resolve4, reject) => {
+    const child = spawn3(command, args, {
+      cwd,
+      stdio: inherit ? "inherit" : ["ignore", "pipe", "pipe"]
+    });
+    let stdout2 = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => stdout2 += chunk.toString());
+    child.stderr?.on("data", (chunk) => stderr += chunk.toString());
+    child.once("error", reject);
+    child.once("exit", (code) => resolve4({ code: code ?? 1, stdout: stdout2, stderr }));
+  });
+}
+async function assertProcess(command, args, cwd, inherit = false) {
+  const result = await captureProcess(command, args, cwd, inherit);
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim();
+    throw new Error(`${command} ${args.join(" ")} 执行失败${detail ? `：${detail}` : ""}`);
+  }
+  return result;
+}
+
+// src/update/transaction.ts
+import {
+  access as access2,
+  copyFile as copyFile2,
+  mkdir as mkdir5,
+  readFile as readFile8,
+  rm as rm5,
+  writeFile as writeFile8
+} from "node:fs/promises";
+import { dirname as dirname3, join as join8 } from "node:path";
+var updateStatePath = ".windy/update-state.json";
+async function applyTransaction(plan) {
+  if (plan.conflicts.length) {
+    throw new Error(`更新存在 ${plan.conflicts.length} 个冲突，未写入任何项目文件`);
+  }
+  const changed = plan.files.filter(({ action }) => action === "create" || action === "update" || action === "delete");
+  for (const file of changed)
+    assertSafePath(file.path);
+  const backupDirectory = join8(plan.projectDirectory, ".windy/backups", plan.id);
+  const protectedPaths = new Set([
+    ...changed.map(({ path: path2 }) => path2),
+    ".windy/generation.json",
+    ".windy/files.json",
+    "bun.lock"
+  ]);
+  const backupEntries = [];
+  for (const path2 of protectedPaths) {
+    const source = join8(plan.projectDirectory, path2);
+    const existed = await exists(source);
+    backupEntries.push({ path: path2, existed });
+    if (!existed)
+      continue;
+    const target = join8(backupDirectory, "files", path2);
+    await mkdir5(dirname3(target), { recursive: true });
+    await copyFile2(source, target);
+  }
+  const state = {
+    schemaVersion: 1,
+    updateId: plan.id,
+    backupDirectory,
+    entries: backupEntries
+  };
+  await writeState(plan.projectDirectory, state);
+  try {
+    for (const file of changed) {
+      const target = join8(plan.projectDirectory, file.path);
+      if (file.action === "delete") {
+        await rm5(target, { force: true });
+        continue;
+      }
+      if (!file.content)
+        throw new Error(`更新计划缺少文件内容：${file.path}`);
+      await mkdir5(dirname3(target), { recursive: true });
+      await writeFile8(target, file.content);
+    }
+  } catch (error) {
+    await restoreUpdateState(plan.projectDirectory, state);
+    throw error;
+  }
+  return {
+    plan,
+    backupDirectory,
+    backupEntries,
+    changedFiles: changed.map(({ path: path2 }) => path2)
+  };
+}
+async function readUpdateState(projectDirectory) {
+  try {
+    const parsed = JSON.parse(await readFile8(join8(projectDirectory, updateStatePath), "utf8"));
+    if (!isUpdateState(parsed))
+      throw new Error("更新恢复状态无效，请人工检查 .windy 目录");
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+async function restoreUpdateState(projectDirectory, state) {
+  for (const entry of state.entries) {
+    assertSafePath(entry.path);
+    const target = join8(projectDirectory, entry.path);
+    if (!entry.existed) {
+      await rm5(target, { force: true });
+      continue;
+    }
+    const backup = join8(state.backupDirectory, "files", entry.path);
+    await mkdir5(dirname3(target), { recursive: true });
+    await copyFile2(backup, target);
+  }
+  await rm5(join8(projectDirectory, updateStatePath), { force: true });
+}
+async function clearUpdateState(projectDirectory) {
+  await rm5(join8(projectDirectory, updateStatePath), { force: true });
+}
+async function writeState(projectDirectory, state) {
+  const path2 = join8(projectDirectory, updateStatePath);
+  await mkdir5(dirname3(path2), { recursive: true });
+  await writeFile8(path2, `${JSON.stringify(state, null, 2)}
+`);
+}
+async function exists(path2) {
+  try {
+    await access2(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertSafePath(path2) {
+  if (!path2 || path2.startsWith("/") || path2.split("/").includes("..")) {
+    throw new Error(`更新计划包含不安全路径：${path2}`);
+  }
+}
+function isUpdateState(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const state = value;
+  return state.schemaVersion === 1 && typeof state.updateId === "string" && typeof state.backupDirectory === "string" && Array.isArray(state.entries);
+}
+
+// src/update/doctor.ts
+var oxcPaths = new Set([
+  ".oxfmtrc.json",
+  ".oxlintrc.json",
+  ".husky/pre-commit"
+]);
+async function diagnoseProject(projectDirectory, repair = false) {
+  const pending = await readUpdateState(projectDirectory);
+  let repaired = false;
+  if (pending && repair) {
+    await restoreUpdateState(projectDirectory, pending);
+    repaired = true;
+  }
+  const [provenance, manifest, git] = await Promise.all([
+    readGenerationProvenance(projectDirectory),
+    readManagedFilesManifest(projectDirectory),
+    captureProcess("git", ["status", "--porcelain"], projectDirectory)
+  ]);
+  const modifiedManagedFiles = [];
+  const missingManagedFiles = [];
+  let detachedToolchain = false;
+  for (const file of manifest.files) {
+    if (file.ownership === "project-owned")
+      continue;
+    try {
+      const changed = hashContent(await readFile9(join9(projectDirectory, file.path))) !== file.hash;
+      if (!changed)
+        continue;
+      modifiedManagedFiles.push(file.path);
+      if (oxcPaths.has(file.path))
+        detachedToolchain = true;
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        missingManagedFiles.push(file.path);
+        if (oxcPaths.has(file.path))
+          detachedToolchain = true;
+        continue;
+      }
+      throw error;
+    }
+  }
+  return {
+    version: provenance.windyVersion,
+    gitClean: git.code === 0 && !git.stdout.trim(),
+    modifiedManagedFiles,
+    missingManagedFiles,
+    detachedToolchain,
+    recoveryRequired: Boolean(pending) && !repaired,
+    repaired
+  };
+}
+
+// src/update/recipes.ts
+var recipes = [
+  { id: "starter-0.1.1-to-0.1.2", from: "0.1.1", to: "0.1.2" },
+  { id: "starter-0.1.2-to-0.2.0", from: "0.1.2", to: "0.2.0" }
+];
+function resolveRecipeChain(sourceVersion, targetVersion) {
+  if (sourceVersion === targetVersion)
+    return [];
+  const chain = [];
+  let current = sourceVersion;
+  const visited = new Set;
+  while (current !== targetVersion) {
+    if (visited.has(current))
+      break;
+    visited.add(current);
+    const recipe = recipes.find(({ from }) => from === current);
+    if (!recipe)
+      break;
+    chain.push(recipe);
+    current = recipe.to;
+  }
+  if (current !== targetVersion) {
+    throw new Error(`没有从 ${sourceVersion} 到 ${targetVersion} 的连续更新 recipe，禁止跳级`);
+  }
+  return chain;
+}
+
+// src/update/updater.ts
+import { mkdir as mkdir7, readFile as readFile12, rm as rm7, writeFile as writeFile10 } from "node:fs/promises";
+import { dirname as dirname4, join as join13 } from "node:path";
+
+// src/update/artifacts.ts
+import { mkdir as mkdir6, mkdtemp, readFile as readFile10 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename as basename3, join as join10 } from "node:path";
+class PublishedArtifactProvider {
+  async prepare(projectDirectory, provenance) {
+    const temporaryRoot = await mkdtemp(join10(tmpdir(), "windy-update-"));
+    const projectName = await readProjectName2(projectDirectory);
+    const baseDirectory = join10(temporaryRoot, "base", projectName);
+    const targetDirectory = join10(temporaryRoot, "target", projectName);
+    await generatePublishedBase(temporaryRoot, projectName, provenance, baseDirectory);
+    await generateProject({
+      sourceRoot: await resolveTemplateRoot(),
+      targetDirectory,
+      projectName,
+      selectedModules: provenance.modules.map(({ name }) => name),
+      includeOxc: provenance.choices.includeOxc,
+      projectLicense: provenance.legalLicense,
+      licenseHolder: provenance.legalLicense === "MIT" ? "Windy project owner" : undefined,
+      profile: provenance.profile
+    });
+    return { temporaryRoot, baseDirectory, targetDirectory };
+  }
+}
+async function generatePublishedBase(temporaryRoot, projectName, provenance, expectedDirectory) {
+  const parent = join10(temporaryRoot, "base");
+  await mkdir6(parent, { recursive: true });
+  const args = [
+    "--bun",
+    `create-windy@${provenance.generatorVersion}`,
+    projectName,
+    "--yes",
+    "--skip-install",
+    "--no-git",
+    "--no-optional-modules",
+    "--license",
+    provenance.legalLicense
+  ];
+  if (!provenance.choices.includeOxc)
+    args.push("--no-oxc");
+  if (provenance.legalLicense === "MIT") {
+    args.push("--license-holder", "Windy project owner");
+  }
+  for (const { name } of provenance.modules) {
+    if (!requiredModuleNames.includes(name)) {
+      args.push("--module", name);
+    }
+  }
+  await assertProcess("bunx", args, parent);
+  if (join10(parent, projectName) !== expectedDirectory) {
+    throw new Error("历史 artifact 生成目录异常");
+  }
+}
+async function readProjectName2(projectDirectory) {
+  const source = JSON.parse(await readFile10(join10(projectDirectory, "package.json"), "utf8"));
+  return source.name || basename3(projectDirectory);
+}
+
+// src/update/planner.ts
+import { access as access3, readFile as readFile11 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+
+// src/update/merge.ts
+import { mkdtemp as mkdtemp2, rm as rm6, writeFile as writeFile9 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join11 } from "node:path";
+async function mergeTextFile(base, ours, theirs) {
+  const root = await mkdtemp2(join11(tmpdir2(), "windy-merge-"));
+  try {
+    const oursPath = join11(root, "ours");
+    const basePath = join11(root, "base");
+    const theirsPath = join11(root, "theirs");
+    await Promise.all([
+      writeFile9(oursPath, ours),
+      writeFile9(basePath, base),
+      writeFile9(theirsPath, theirs)
+    ]);
+    const result = await captureProcess("git", ["merge-file", "-p", "--diff3", oursPath, basePath, theirsPath], root);
+    if (result.code === 0) {
+      return { content: new TextEncoder().encode(result.stdout) };
+    }
+    if (result.code === 1)
+      return { conflict: "三方合并存在重叠修改" };
+    return { conflict: result.stderr.trim() || "git merge-file 执行失败" };
+  } finally {
+    await rm6(root, { recursive: true, force: true });
+  }
+}
+
+// src/update/package-merge.ts
+function mergePackageJson(base, ours, theirs) {
+  const conflicts = [];
+  const merged = mergeValue(JSON.parse(new TextDecoder().decode(base)), JSON.parse(new TextDecoder().decode(ours)), JSON.parse(new TextDecoder().decode(theirs)), "package.json", conflicts);
+  return conflicts.length ? { conflicts } : {
+    conflicts,
+    content: new TextEncoder().encode(`${JSON.stringify(merged, null, 2)}
+`)
+  };
+}
+function mergeValue(base, ours, theirs, path2, conflicts) {
+  if (equal(ours, theirs))
+    return ours;
+  if (equal(ours, base))
+    return theirs;
+  if (equal(theirs, base))
+    return ours;
+  if (isObject(base) && isObject(ours) && isObject(theirs)) {
+    const output = {};
+    const keys = new Set([
+      ...Object.keys(base),
+      ...Object.keys(ours),
+      ...Object.keys(theirs)
+    ]);
+    for (const key of keys) {
+      const value = mergeValue(base[key], ours[key], theirs[key], `${path2}.${key}`, conflicts);
+      if (value !== undefined)
+        output[key] = value;
+    }
+    return output;
+  }
+  conflicts.push(path2);
+  return ours;
+}
+function equal(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/update/planner.ts
+var metadataPaths = new Set([
+  ".windy/generation.json",
+  ".windy/files.json",
+  ".windy-template.json"
+]);
+var oxcManagedPaths = new Set([
+  ".oxfmtrc.json",
+  ".oxlintrc.json",
+  ".husky/pre-commit"
+]);
+async function createUpdatePlan(request, artifacts) {
+  await assertGitClean(request.projectDirectory);
+  await assertNoPendingUpdate(request.projectDirectory);
+  const provenance = await readGenerationProvenance(request.projectDirectory);
+  const artifactSet = await artifacts.prepare(request.projectDirectory, provenance);
+  const targetProvenance = await readGenerationProvenance(artifactSet.targetDirectory);
+  const targetVersion = request.targetVersion || targetProvenance.generatorVersion;
+  if (targetVersion !== targetProvenance.generatorVersion) {
+    throw new Error(`当前 CLI 只能更新到 ${targetProvenance.generatorVersion}，请运行 create-windy@${targetVersion}`);
+  }
+  const recipes2 = resolveRecipeChain(provenance.windyVersion, targetVersion);
+  const [sourceManifest, targetManifest] = await Promise.all([
+    readManagedFilesManifest(request.projectDirectory),
+    readManagedFilesManifest(artifactSet.targetDirectory)
+  ]);
+  targetProvenance.appliedRecipes = [
+    ...provenance.appliedRecipes,
+    ...recipes2.map(({ id }) => id)
+  ];
+  const sourceEntries = new Map(sourceManifest.files.map((item) => [item.path, item]));
+  const targetEntries = new Map(targetManifest.files.map((item) => [item.path, item]));
+  const paths = new Set([...sourceEntries.keys(), ...targetEntries.keys()]);
+  const files = [];
+  let detachedToolchain = false;
+  for (const path2 of [...paths].sort()) {
+    if (metadataPaths.has(path2))
+      continue;
+    const file = await planFile(path2, request.projectDirectory, artifactSet.baseDirectory, artifactSet.targetDirectory, sourceEntries.get(path2), targetEntries.get(path2));
+    if (oxcManagedPaths.has(path2) && file.reason === "客户已修改") {
+      file.action = "preserve";
+      delete file.conflict;
+      detachedToolchain = true;
+    }
+    files.push(file);
+  }
+  const conflicts = files.flatMap((file) => file.conflict ? [`${file.path}：${file.conflict}`] : []);
+  return {
+    id: createUpdateId(provenance.windyVersion, targetVersion),
+    projectDirectory: request.projectDirectory,
+    sourceVersion: provenance.windyVersion,
+    targetVersion,
+    recipes: recipes2.map(({ id }) => id),
+    files,
+    conflicts,
+    detachedToolchain,
+    targetProvenance,
+    targetManifest,
+    temporaryRoot: artifactSet.temporaryRoot
+  };
+}
+async function planFile(path2, project, baseRoot, targetRoot, source, target) {
+  const [ours, base, theirs] = await Promise.all([
+    readOptional(join12(project, path2)),
+    readOptional(join12(baseRoot, path2)),
+    readOptional(join12(targetRoot, path2))
+  ]);
+  const ownership = target?.ownership || source?.ownership || classifyOwnership(path2);
+  if (path2.startsWith("packages/database/drizzle/") && path2.endsWith(".sql")) {
+    if (source && !target)
+      return conflict(path2, ownership, "已发布 migration 不可删除");
+    if (source && target && source.hash !== target.hash) {
+      return conflict(path2, ownership, "已发布 migration 不可改写，只能追加新文件");
+    }
+  }
+  if (ownership === "project-owned") {
+    if (!ours && theirs)
+      return ready(path2, ownership, "create", "新增项目扩展点", theirs);
+    return ready(path2, ownership, "preserve", "项目拥有，Windy 不覆盖");
+  }
+  if (!source && target) {
+    if (!ours)
+      return ready(path2, ownership, "create", "目标版本新增", theirs);
+    if (theirs && hashContent(ours) === target.hash) {
+      return ready(path2, ownership, "preserve", "已包含目标内容");
+    }
+    return conflict(path2, ownership, "目标版本新增路径已被项目占用");
+  }
+  if (source && !target) {
+    if (!ours)
+      return ready(path2, ownership, "preserve", "项目已删除");
+    if (hashContent(ours) === source.hash) {
+      return ready(path2, ownership, "delete", "目标版本删除");
+    }
+    return conflict(path2, ownership, "客户修改后 Windy 又删除");
+  }
+  if (!source || !target || !ours || !theirs) {
+    return conflict(path2, ownership, "文件状态不完整，不能安全推断");
+  }
+  const oursChanged = hashContent(ours) !== source.hash;
+  const targetChanged = target.hash !== source.hash;
+  if (!oursChanged && !targetChanged)
+    return ready(path2, ownership, "preserve", "双方未修改");
+  if (!oursChanged)
+    return ready(path2, ownership, "update", "仅 Windy 修改", theirs);
+  if (!targetChanged)
+    return ready(path2, ownership, "preserve", "客户已修改");
+  if (hashContent(ours) === target.hash)
+    return ready(path2, ownership, "preserve", "已包含目标内容");
+  if (path2 === "package.json" && base) {
+    const merged = mergePackageJson(base, ours, theirs);
+    return merged.content ? ready(path2, ownership, "update", "package.json 字段级合并", merged.content) : conflict(path2, ownership, `字段冲突：${merged.conflicts.join("、")}`);
+  }
+  if (ownership === "shared-scaffold" && base) {
+    const merged = await mergeTextFile(base, ours, theirs);
+    return merged.content ? ready(path2, ownership, "update", "三方合并", merged.content) : conflict(path2, ownership, merged.conflict || "三方合并失败");
+  }
+  return conflict(path2, ownership, "客户和 Windy 均已修改");
+}
+function ready(path2, ownership, action, reason, content) {
+  return { path: path2, ownership, action, reason, content };
+}
+function conflict(path2, ownership, reason) {
+  return {
+    path: path2,
+    ownership,
+    action: "preserve",
+    reason: "客户已修改",
+    conflict: reason
+  };
+}
+async function readOptional(path2) {
+  try {
+    return await readFile11(path2);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+async function assertGitClean(projectDirectory) {
+  const result = await captureProcess("git", ["status", "--porcelain"], projectDirectory);
+  if (result.code !== 0)
+    throw new Error("更新要求当前目录是有效的 Git 仓库");
+  if (result.stdout.trim())
+    throw new Error("更新前请先提交或暂存之外妥善处理 Git 工作区改动");
+}
+async function assertNoPendingUpdate(projectDirectory) {
+  try {
+    await access3(join12(projectDirectory, ".windy/update-state.json"));
+    throw new Error("检测到未完成更新，请先运行 bun run windy doctor --repair");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function createUpdateId(from, to) {
+  return `${new Date().toISOString().replaceAll(/[:.]/g, "-")}-${from}-to-${to}`;
+}
+
+// src/update/updater.ts
+class DefaultStarterUpdater {
+  #artifacts;
+  #execute;
+  constructor(dependencies = {}) {
+    this.#artifacts = dependencies.artifacts ?? new PublishedArtifactProvider;
+    this.#execute = dependencies.execute ?? runCommand;
+  }
+  async plan(input) {
+    return await createUpdatePlan(input, this.#artifacts);
+  }
+  async apply(plan) {
+    try {
+      return await applyTransaction(plan);
+    } catch (error) {
+      await rm7(plan.temporaryRoot, { recursive: true, force: true });
+      throw error;
+    }
+  }
+  async verify(result) {
+    const steps = [];
+    try {
+      await this.#execute("bun", ["install"], result.plan.projectDirectory);
+      steps.push({ name: "bun install", status: "passed" });
+      const packageJson = JSON.parse(await readFile12(join13(result.plan.projectDirectory, "package.json"), "utf8"));
+      for (const name of ["lint", "typecheck", "test", "build"]) {
+        if (!packageJson.scripts?.[name]) {
+          steps.push({ name: `bun run ${name}`, status: "skipped" });
+          continue;
+        }
+        await this.#execute("bun", ["run", name], result.plan.projectDirectory);
+        steps.push({ name: `bun run ${name}`, status: "passed" });
+      }
+      await finalize(result);
+      const reportPath = `.windy/reports/${result.plan.id}.md`;
+      await writeReport(result, steps, reportPath);
+      await clearUpdateState(result.plan.projectDirectory);
+      await rm7(result.plan.temporaryRoot, { recursive: true, force: true });
+      return { updateId: result.plan.id, status: "passed", steps, reportPath };
+    } catch (error) {
+      await restoreUpdateState(result.plan.projectDirectory, {
+        schemaVersion: 1,
+        updateId: result.plan.id,
+        backupDirectory: result.backupDirectory,
+        entries: result.backupEntries
+      });
+      await rm7(result.plan.temporaryRoot, { recursive: true, force: true });
+      throw new Error(`更新验证失败，项目已回滚到 ${result.plan.sourceVersion}：${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+  }
+}
+async function finalize(result) {
+  const root = result.plan.projectDirectory;
+  await writeFile10(join13(root, ".windy/generation.json"), `${JSON.stringify(result.plan.targetProvenance, null, 2)}
+`);
+  await writeFile10(join13(root, ".windy/files.json"), `${JSON.stringify(result.plan.targetManifest, null, 2)}
+`);
+}
+async function writeReport(result, steps, relativePath2) {
+  const path2 = join13(result.plan.projectDirectory, relativePath2);
+  await mkdir7(dirname4(path2), { recursive: true });
+  const lines = [
+    `# Windy 更新报告 ${result.plan.id}`,
+    "",
+    `- 来源版本：${result.plan.sourceVersion}`,
+    `- 目标版本：${result.plan.targetVersion}`,
+    `- Recipe：${result.plan.recipes.join("、") || "无"}`,
+    `- 修改文件：${result.changedFiles.length}`,
+    `- Oxc 代管：${result.plan.detachedToolchain ? "已检测到客户接管并保留" : "保持"}`,
+    "",
+    "## 验证",
+    "",
+    ...steps.map(({ name, status }) => `- ${name}：${status}`),
+    "",
+    `备份保留在 \`.windy/backups/${result.plan.id}\`，确认稳定后可人工删除。`,
+    ""
+  ];
+  await writeFile10(path2, lines.join(`
+`));
+}
+
+// src/update/cli.ts
+async function runLifecycleCommand(args) {
+  const command = args[0];
+  if (command !== "doctor" && command !== "update")
+    return false;
+  const projectDirectory = resolve4(readValue2(args, "--cwd") || process.cwd());
+  if (command === "doctor") {
+    const report = await diagnoseProject(projectDirectory, args.includes("--repair"));
+    printDoctor(report);
+    if (report.recoveryRequired)
+      process.exitCode = 1;
+    return true;
+  }
+  await runUpdate(args, projectDirectory);
+  return true;
+}
+async function runUpdate(args, projectDirectory) {
+  const template = await readTemplateMetadata(await resolveTemplateRoot());
+  const requested = readValue2(args, "--to");
+  const registryVersion = requested ? undefined : await readRegistryLatest();
+  if (registryVersion && compareVersions2(registryVersion, template.generatorVersion) > 0 && !args.includes("--no-delegate")) {
+    if (args.includes("--check")) {
+      const current2 = await readGenerationProvenance(projectDirectory);
+      console.log(`可更新：${current2.windyVersion} → ${registryVersion}（请使用新版 CLI 生成完整计划）`);
+      return;
+    }
+    await delegateUpdate(args, registryVersion, projectDirectory);
+    return;
+  }
+  if (requested && requested !== template.generatorVersion && !args.includes("--no-delegate")) {
+    await delegateUpdate(args, requested, projectDirectory);
+    return;
+  }
+  const current = await readGenerationProvenance(projectDirectory);
+  const target = requested || template.generatorVersion;
+  const recipes2 = resolveRecipeChain(current.windyVersion, target);
+  if (args.includes("--check")) {
+    console.log(recipes2.length ? `可更新：${current.windyVersion} → ${target}（${recipes2.length} 个连续 recipe）` : `已是当前 CLI 支持的最新版本 ${current.windyVersion}`);
+    return;
+  }
+  if (!recipes2.length) {
+    console.log(`项目已经是 ${target}，无需更新`);
+    return;
+  }
+  const updater = new DefaultStarterUpdater;
+  const plan = await updater.plan({ projectDirectory, targetVersion: target });
+  printPlan(plan);
+  if (args.includes("--dry-run")) {
+    await rm8(plan.temporaryRoot, { recursive: true, force: true });
+    console.log(`
+演练完成：未写入项目文件`);
+    return;
+  }
+  if (plan.conflicts.length) {
+    await rm8(plan.temporaryRoot, { recursive: true, force: true });
+    throw new Error("存在更新冲突；请按上方清单处理后重新运行，项目未被修改");
+  }
+  const result = await updater.apply(plan);
+  const report = await updater.verify(result);
+  console.log(`
+更新完成：${plan.sourceVersion} → ${plan.targetVersion}`);
+  console.log(`报告：${report.reportPath}`);
+}
+async function delegateUpdate(args, target, projectDirectory) {
+  const forwarded = args.slice(1).filter((item, index, all) => {
+    if (item === "--cwd" || item === "--to")
+      return false;
+    return all[index - 1] !== "--cwd" && all[index - 1] !== "--to";
+  });
+  await assertProcess("bunx", [
+    "--bun",
+    `create-windy@${target}`,
+    "update",
+    "--cwd",
+    projectDirectory,
+    "--to",
+    target,
+    "--no-delegate",
+    ...forwarded
+  ], projectDirectory, true);
+}
+function printPlan(plan) {
+  const changed = plan.files.filter(({ action }) => action !== "preserve");
+  console.log(`Windy 更新计划：${plan.sourceVersion} → ${plan.targetVersion}`);
+  console.log(`Recipe：${plan.recipes.join("、")}`);
+  console.log(`计划改动：${changed.length} 个文件；冲突：${plan.conflicts.length}`);
+  for (const file of changed)
+    console.log(`  ${file.action.padEnd(6)} ${file.path}（${file.reason}）`);
+  for (const conflict2 of plan.conflicts)
+    console.log(`  conflict ${conflict2}`);
+  if (plan.detachedToolchain)
+    console.log("Oxc：检测到客户接管，相关配置保持不变");
+}
+function printDoctor(report) {
+  console.log(`Windy Project Lock：${report.version}`);
+  console.log(`Git 工作区：${report.gitClean ? "干净" : "有改动"}`);
+  console.log(`客户修改的受管文件：${report.modifiedManagedFiles.length}`);
+  console.log(`缺失的受管文件：${report.missingManagedFiles.length}`);
+  console.log(`Oxc：${report.detachedToolchain ? "客户已接管" : "仍由 Windy 代管或未启用"}`);
+  if (report.recoveryRequired)
+    console.log("恢复：检测到中断更新，请运行 doctor --repair");
+  if (report.repaired)
+    console.log("恢复：已从事务备份回滚");
+}
+function readValue2(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+async function readRegistryLatest() {
+  try {
+    const response = await fetch("https://registry.npmjs.org/create-windy/latest");
+    if (!response.ok)
+      return;
+    const payload = await response.json();
+    return payload.version;
+  } catch {
+    return;
+  }
+}
+function compareVersions2(left, right) {
+  const leftParts = left.split(".").map(Number);
+  const rightParts = right.split(".").map(Number);
+  for (let index = 0;index < 3; index += 1) {
+    const difference = (leftParts[index] || 0) - (rightParts[index] || 0);
+    if (difference)
+      return difference;
+  }
+  return 0;
+}
+
+// src/cli.ts
+async function main() {
+  const args = process.argv.slice(2);
+  if (await runLifecycleCommand(args))
+    return;
+  const options = parseArguments(args);
   if (options === "help") {
     console.log(helpText);
     return;