create-windy 0.1.2 → 0.2.0

package/dist/cli.js

@@ -688,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
@@ -799,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) {
@@ -808,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) {
@@ -874,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 工具；项目所有者可按团队需要自行选择。";
@@ -895,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") {
@@ -944,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",
@@ -977,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";
@@ -997,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;
       }
@@ -1009,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";
@@ -1294,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` 示例模块，当前项目只包含平台模块。"}
 
 ## 环境要求
@@ -1362,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 关闭当成
+模块已经卸载。
 
 ## 常用命令
 
@@ -1373,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 的页面允许匿名访问。
@@ -1399,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",
@@ -1434,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 } : {}
+    }
   };
 }
 
@@ -1445,6 +1529,7 @@ function createStarterPackage(source, projectName, includeOxc = true, projectLic
 var templateRootFiles = [
   ".dockerignore",
   ".gitignore",
+  ".husky/pre-commit",
   ".oxfmtrc.json",
   ".oxlintrc.json",
   "AGENTS.md",
@@ -1505,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",
@@ -1534,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]));
@@ -1571,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;
@@ -1594,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);
@@ -1729,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(`
@@ -3421,19 +3528,27 @@ var dist_default4 = createPrompt((config, done) => {
 });
 
 // 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.selectModules({
-    choices: optional.map(({ name, label, selection }) => ({
-      value: name,
-      label: `${label} (${name})`,
-      hint: selection === "recommended" ? "推荐，默认选中" : "可选"
-    })),
-    defaults: [...recommendedModuleNames]
+  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 = await prompter.confirm("是否引入 Oxlint + Oxfmt？", true);
+  const includeOxc = requested.includes(oxcChoiceKey);
   const projectLicense = await prompter.selectLicense();
   const licenseHolder = projectLicense === "MIT" ? (await prompter.text("MIT 许可证权利人名称：")).trim() : undefined;
   if (projectLicense === "MIT" && !licenseHolder) {
@@ -3441,7 +3556,7 @@ async function applyInteractiveSelection(options, prompter = terminalPrompter())
   }
   const selectedModules = resolveModuleSelection({
     includeRecommended: false,
-    requested
+    requested: requested.filter((value) => value !== oxcChoiceKey)
   });
   return {
     ...options,
@@ -3463,9 +3578,9 @@ function terminalPrompter() {
     }
   };
   return {
-    async selectModules({ choices, defaults }) {
+    async selectGenerationChoices({ choices, defaults }) {
       return dist_default4({
-        message: "请选择要生成的平台模块",
+        message: "请选择要生成的平台模块和基础设施",
         choices: choices.map((choice) => ({
           value: choice.value,
           name: choice.label,
@@ -3482,13 +3597,6 @@ function terminalPrompter() {
         }
       });
     },
-    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();
@@ -3505,10 +3613,755 @@ function terminalPrompter() {
     }
   };
 }
+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 options = parseArguments(process.argv.slice(2));
+  const args = process.argv.slice(2);
+  if (await runLifecycleCommand(args))
+    return;
+  const options = parseArguments(args);
   if (options === "help") {
     console.log(helpText);
     return;