@wneng/create-keel 0.1.0

package/dist/index.js

@@ -0,0 +1,1479 @@
+#!/usr/bin/env node
+
+// src/version.ts
+var SCAFFOLDER_VERSION = "0.1.0";
+
+// src/schema/options.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { parse as parseYaml } from "yaml";
+var BACKEND_LANGUAGES = ["node", "python", "go", "java", "none"];
+var FRONTEND_FRAMEWORKS = ["react", "vue", "none"];
+var AGENT_KINDS = ["rust-desktop", "none"];
+var MOBILE_KINDS = ["react-native", "flutter", "none"];
+var MINIAPP_KINDS = ["wechat", "none"];
+var DEPLOY_TARGETS = ["docker-compose", "kubernetes", "bare-metal", "none"];
+var CONTRACT_KINDS = ["rest", "rest+events", "events-only", "none"];
+var AI_TOOLS = ["kiro", "cursor", "claude-code", "codex", "none"];
+var LICENSE_KINDS = ["mit", "apache-2.0", "proprietary"];
+var CI_PLATFORMS = ["gitee", "github"];
+var ROLE_KINDS = ["design", "qa", "field", "data", "legal-security", "marketing"];
+var PROJECT_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,62}$/;
+var PROJECT_NAME_PATTERN_SOURCE = "^[a-z0-9][a-z0-9-]{0,62}$";
+var OPTIONS_FIELD_ORDER = [
+  "projectName",
+  "backend",
+  "frontend",
+  "mobile",
+  "miniapp",
+  "agent",
+  "deploy",
+  "contract",
+  "ai",
+  "license",
+  "gitLfs",
+  "integrations",
+  "ci",
+  "roles"
+];
+var OPTIONS_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://cgsy.example.com/schemas/scaffolder/options.json",
+  title: "ScaffolderOptions",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "projectName",
+    "backend",
+    "frontend",
+    "mobile",
+    "miniapp",
+    "agent",
+    "deploy",
+    "contract",
+    "ai",
+    "license",
+    "gitLfs",
+    "integrations",
+    "ci",
+    "roles"
+  ],
+  properties: {
+    projectName: {
+      type: "string",
+      pattern: PROJECT_NAME_PATTERN_SOURCE
+    },
+    backend: { type: "string", enum: [...BACKEND_LANGUAGES] },
+    frontend: { type: "string", enum: [...FRONTEND_FRAMEWORKS] },
+    mobile: { type: "string", enum: [...MOBILE_KINDS] },
+    miniapp: { type: "string", enum: [...MINIAPP_KINDS] },
+    agent: { type: "string", enum: [...AGENT_KINDS] },
+    deploy: { type: "string", enum: [...DEPLOY_TARGETS] },
+    contract: { type: "string", enum: [...CONTRACT_KINDS] },
+    ai: { type: "string", enum: [...AI_TOOLS] },
+    license: { type: "string", enum: [...LICENSE_KINDS] },
+    gitLfs: { type: "boolean" },
+    integrations: { type: "boolean" },
+    ci: { type: "string", enum: [...CI_PLATFORMS] },
+    roles: {
+      type: "array",
+      items: { type: "string", enum: [...ROLE_KINDS] },
+      uniqueItems: true
+    }
+  }
+};
+var ajv = new Ajv({ allErrors: true, strict: true });
+addFormats(ajv);
+var validateFn = ajv.compile(OPTIONS_SCHEMA);
+var OptionsValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(
+      `Invalid Scaffolder options:
+` + issues.map((i) => `  - ${i.path || "<root>"}: ${i.message}`).join("\n")
+    );
+    this.name = "OptionsValidationError";
+    this.issues = issues;
+  }
+};
+function collectIssues() {
+  const errs = validateFn.errors ?? [];
+  return errs.map((e) => ({
+    path: e.instancePath || (e.params && "missingProperty" in e.params ? `/${String(e.params.missingProperty)}` : ""),
+    message: e.message ?? "validation error"
+  }));
+}
+function assertOptions(value) {
+  if (!validateFn(value)) {
+    throw new OptionsValidationError(collectIssues());
+  }
+  return value;
+}
+
+// src/errors.ts
+var ScaffolderError = class extends Error {
+  suggestion;
+  constructor(message, suggestion) {
+    super(message);
+    this.name = new.target.name;
+    this.suggestion = suggestion;
+  }
+  toThreeLine() {
+    return { title: this.title, message: this.message, suggestion: this.suggestion };
+  }
+};
+var UserInputError = class extends ScaffolderError {
+  exitCode = 1;
+  title = "UserInputError";
+};
+var FilesystemError = class extends ScaffolderError {
+  exitCode = 2;
+  title = "FilesystemError";
+};
+var TemplateError = class extends ScaffolderError {
+  exitCode = 3;
+  title = "TemplateError";
+};
+function formatError(err) {
+  if (err instanceof ScaffolderError) {
+    const { title, message, suggestion } = err.toThreeLine();
+    return `\u2717 ${title}
+  ${message}
+  \u5EFA\u8BAE\uFF1A${suggestion}`;
+  }
+  if (err instanceof Error) {
+    return `\u2717 UnexpectedError
+  ${err.message}
+  \u5EFA\u8BAE\uFF1A\u8BF7\u5728 issue \u4E2D\u9644\u4E0A\u5B8C\u6574\u5806\u6808`;
+  }
+  return `\u2717 UnexpectedError
+  ${String(err)}
+  \u5EFA\u8BAE\uFF1A\u8BF7\u5728 issue \u4E2D\u9644\u4E0A\u5B8C\u6574\u4E0A\u4E0B\u6587`;
+}
+
+// src/cli.ts
+async function run(io) {
+  const args = io.argv.slice(2);
+  if (args.some((a) => a === "-h" || a === "--help")) {
+    io.stdout(helpText());
+    return 0;
+  }
+  if (args.some((a) => a === "-v" || a === "--version")) {
+    io.stdout(SCAFFOLDER_VERSION);
+    return 0;
+  }
+  if (args.length === 0) {
+    io.stdout(helpText());
+    return 0;
+  }
+  const [command, ...rest] = args;
+  if (command !== "create") {
+    io.stderr(
+      formatError(
+        new UserInputError(
+          `unknown command: ${JSON.stringify(command)}`,
+          "\u53EF\u7528\u7684\u547D\u4EE4\uFF1Acreate\u3002\u67E5\u770B\u5E2E\u52A9\uFF1A--help"
+        )
+      )
+    );
+    return 1;
+  }
+  try {
+    const { projectName, flags } = parseCreateArgs(rest);
+    await io.onCreate({ projectName, flags });
+    return 0;
+  } catch (err) {
+    io.stderr(formatError(err));
+    if (err instanceof ScaffolderError) {
+      return err.exitCode;
+    }
+    return 1;
+  }
+}
+function parseCreateArgs(args) {
+  let projectName;
+  let yes = false;
+  let force = false;
+  let dryRun = false;
+  let quiet = false;
+  let verbose = false;
+  let config;
+  let ci;
+  let roles;
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    switch (a) {
+      case "--yes":
+        yes = true;
+        break;
+      case "--force":
+        force = true;
+        break;
+      case "--dry-run":
+        dryRun = true;
+        break;
+      case "--quiet":
+        quiet = true;
+        break;
+      case "--verbose":
+        verbose = true;
+        break;
+      case "--config": {
+        const next = args[i + 1];
+        if (next === void 0 || next.startsWith("--")) {
+          throw new UserInputError(
+            "--config requires a path argument",
+            "\u793A\u4F8B\uFF1A--config ./scaffolder.yaml"
+          );
+        }
+        config = next;
+        i += 1;
+        break;
+      }
+      case "--ci": {
+        const next = args[i + 1];
+        if (next !== "gitee" && next !== "github") {
+          throw new UserInputError(
+            `invalid --ci value: ${JSON.stringify(next ?? "")}`,
+            "--ci \u53EA\u63A5\u53D7 gitee \u6216 github"
+          );
+        }
+        ci = next;
+        i += 1;
+        break;
+      }
+      case "--roles": {
+        const next = args[i + 1];
+        if (next === void 0 || next.startsWith("--")) {
+          throw new UserInputError(
+            "--roles requires a comma-separated list",
+            "\u793A\u4F8B\uFF1A--roles qa,field,marketing\uFF1B\u53EF\u9009\u503C\uFF1A" + ROLE_KINDS.join(",")
+          );
+        }
+        const parts = next.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+        const seen = /* @__PURE__ */ new Set();
+        for (const part of parts) {
+          if (!ROLE_KINDS.includes(part)) {
+            throw new UserInputError(
+              `invalid --roles value: ${JSON.stringify(part)}`,
+              "\u53EF\u9009\u89D2\u8272\uFF1A" + ROLE_KINDS.join(",")
+            );
+          }
+          if (seen.has(part)) {
+            throw new UserInputError(
+              `duplicate role: ${part}`,
+              "--roles \u4E2D\u6BCF\u4E2A\u89D2\u8272\u4EC5\u80FD\u51FA\u73B0\u4E00\u6B21"
+            );
+          }
+          seen.add(part);
+        }
+        roles = parts;
+        i += 1;
+        break;
+      }
+      default: {
+        if (a.startsWith("--")) {
+          throw new UserInputError(
+            `unknown option: ${a}`,
+            "\u67E5\u770B\u53EF\u7528\u9009\u9879\uFF1Acreate-keel --help"
+          );
+        }
+        if (projectName === void 0) {
+          projectName = a;
+        } else {
+          throw new UserInputError(
+            `unexpected extra argument: ${JSON.stringify(a)}`,
+            "\u6BCF\u6B21\u53EA\u80FD\u521B\u5EFA\u4E00\u4E2A\u9879\u76EE"
+          );
+        }
+      }
+    }
+  }
+  if (projectName === void 0) {
+    throw new UserInputError(
+      "missing <project-name>",
+      "\u8BF7\u63D0\u4F9B\u9879\u76EE\u540D\uFF0C\u4F8B\u5982\uFF1Anpx @wneng/create-keel create my-app"
+    );
+  }
+  if (!PROJECT_NAME_PATTERN.test(projectName)) {
+    throw new UserInputError(
+      `invalid project name: ${JSON.stringify(projectName)}`,
+      "\u9879\u76EE\u540D\u5E94\u5339\u914D ^[a-z0-9][a-z0-9-]{0,62}$\uFF0C\u4F8B\u5982\uFF1Amy-app"
+    );
+  }
+  const flags = {
+    yes,
+    force,
+    dryRun,
+    quiet,
+    verbose,
+    ...config !== void 0 ? { config } : {},
+    ...ci !== void 0 ? { ci } : {},
+    ...roles !== void 0 ? { roles } : {}
+  };
+  return { projectName, flags };
+}
+function helpText() {
+  return [
+    "create-keel \u2014 scaffold a Contract-First project",
+    "",
+    "USAGE",
+    "  npx @wneng/create-keel create <project-name> [options]",
+    "",
+    "OPTIONS",
+    "  --yes              Skip interactive prompts and use defaults",
+    "  --force            Overwrite a non-empty target directory after confirmation",
+    "  --dry-run          Compute the plan without writing any files",
+    "  --quiet            Only emit errors and the final summary",
+    "  --verbose          Emit per-file render/write logs",
+    "  --config <path>    Read options from a JSON or YAML file",
+    "  --ci <platform>    Which CI platform to scaffold (gitee|github, default: gitee)",
+    "  --roles <list>     Comma-separated role directories to scaffold",
+    "                     (" + ROLE_KINDS.join("|") + "; default: none)",
+    "  -h, --help         Show this help",
+    "  -v, --version      Show the scaffolder version",
+    "",
+    "See .kiro/specs/project-scaffolder/ for the full specification."
+  ].join("\n");
+}
+
+// src/orchestrator.ts
+import * as path5 from "node:path";
+
+// src/input/defaults.ts
+var OPTION_DEFAULTS = {
+  backend: "node",
+  frontend: "react",
+  mobile: "none",
+  miniapp: "none",
+  agent: "none",
+  deploy: "docker-compose",
+  contract: "rest",
+  ai: "kiro",
+  license: "mit",
+  gitLfs: false,
+  integrations: false,
+  ci: "gitee",
+  roles: []
+};
+function buildDefaultOptions(projectName) {
+  return { projectName, ...OPTION_DEFAULTS };
+}
+
+// src/input/config.ts
+import Ajv2 from "ajv";
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { parse as parseYaml2 } from "yaml";
+var PARTIAL_OPTIONS_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://cgsy.example.com/schemas/scaffolder/partial-options.json",
+  title: "PartialScaffolderOptions",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    projectName: { type: "string", pattern: PROJECT_NAME_PATTERN_SOURCE },
+    backend: { type: "string", enum: [...BACKEND_LANGUAGES] },
+    frontend: { type: "string", enum: [...FRONTEND_FRAMEWORKS] },
+    mobile: { type: "string", enum: [...MOBILE_KINDS] },
+    miniapp: { type: "string", enum: [...MINIAPP_KINDS] },
+    agent: { type: "string", enum: [...AGENT_KINDS] },
+    deploy: { type: "string", enum: [...DEPLOY_TARGETS] },
+    contract: { type: "string", enum: [...CONTRACT_KINDS] },
+    ai: { type: "string", enum: [...AI_TOOLS] },
+    license: { type: "string", enum: [...LICENSE_KINDS] },
+    gitLfs: { type: "boolean" },
+    integrations: { type: "boolean" },
+    ci: { type: "string", enum: [...CI_PLATFORMS] },
+    roles: {
+      type: "array",
+      items: { type: "string", enum: [...ROLE_KINDS] },
+      uniqueItems: true
+    }
+  }
+};
+var ajv2 = new Ajv2({ allErrors: true, strict: true });
+var validate = ajv2.compile(
+  PARTIAL_OPTIONS_SCHEMA
+);
+function formatIssues() {
+  const errs = validate.errors ?? [];
+  return errs.map((e) => {
+    const path6 = e.instancePath || (e.params && "missingProperty" in e.params ? `/${String(e.params.missingProperty)}` : "<root>");
+    return `${path6}: ${e.message ?? "validation error"}`;
+  }).join("; ");
+}
+async function loadConfigFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const isJson = ext === ".json";
+  const isYaml = ext === ".yaml" || ext === ".yml";
+  if (!isJson && !isYaml) {
+    throw new UserInputError(
+      `unsupported config extension: ${ext || "<none>"}`,
+      "\u8BF7\u4F7F\u7528 .json \u6216 .yaml / .yml \u6587\u4EF6"
+    );
+  }
+  let text;
+  try {
+    text = await fs.readFile(filePath, "utf8");
+  } catch (e) {
+    throw new UserInputError(
+      `failed to read config file: ${e.message}`,
+      "\u8BF7\u786E\u8BA4\u6587\u4EF6\u8DEF\u5F84\u5B58\u5728\u4E14\u53EF\u8BFB"
+    );
+  }
+  let raw;
+  try {
+    raw = isJson ? JSON.parse(text) : parseYaml2(text);
+  } catch (e) {
+    throw new UserInputError(
+      `invalid ${isJson ? "JSON" : "YAML"} in config: ${e.message}`,
+      "\u8BF7\u68C0\u67E5\u6587\u4EF6\u5185\u5BB9\u662F\u5426\u4E3A\u5408\u6CD5\u7684 JSON / YAML"
+    );
+  }
+  if (raw === null || raw === void 0) {
+    return {};
+  }
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new UserInputError(
+      "config root must be an object",
+      '\u793A\u4F8B\uFF1A{ "backend": "node", "frontend": "react" }'
+    );
+  }
+  if (!validate(raw)) {
+    throw new UserInputError(
+      `config file does not match schema: ${formatIssues()}`,
+      "\u53C2\u8003 defaults \u4E2D\u7684\u5B57\u6BB5\u540D\u4E0E\u53D6\u503C\u57DF"
+    );
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+
+// src/input/prompter.ts
+var InquirerPrompter = class {
+  async input(question, validate2) {
+    const { input } = await import("@inquirer/prompts");
+    return input({ message: question, validate: validate2 });
+  }
+  async select(question, choices, def) {
+    const { select } = await import("@inquirer/prompts");
+    return await select({
+      message: question,
+      choices: choices.map((c) => ({ name: c.name, value: c.value })),
+      default: def
+    });
+  }
+  async confirm(question, def) {
+    const { confirm } = await import("@inquirer/prompts");
+    return confirm({ message: question, default: def });
+  }
+  async checkbox(question, choices, def) {
+    const { checkbox } = await import("@inquirer/prompts");
+    const defSet = new Set(def);
+    return await checkbox({
+      message: question,
+      choices: choices.map((c) => ({
+        name: c.name,
+        value: c.value,
+        checked: defSet.has(c.value)
+      }))
+    });
+  }
+};
+function stringChoices(values) {
+  return values.map((v) => ({ value: v, name: v }));
+}
+async function promptForOptions(input) {
+  if (!input.isTTY) {
+    throw new UserInputError(
+      "interactive prompts require a TTY",
+      "\u8BF7\u5728\u4EA4\u4E92\u7EC8\u7AEF\u4E2D\u8FD0\u884C\uFF0C\u6216\u63D0\u4F9B --yes / --config"
+    );
+  }
+  const p = input.prompter;
+  const pre = input.prefilled;
+  const report = input.report ?? (() => {
+  });
+  const projectName = pre.projectName ?? await p.input("\u9879\u76EE\u540D", (v) => {
+    if (!PROJECT_NAME_PATTERN.test(v)) {
+      return "\u9879\u76EE\u540D\u5E94\u5339\u914D ^[a-z0-9][a-z0-9-]{0,62}$";
+    }
+    return true;
+  });
+  report("projectName", projectName, false);
+  const backend = await chooseAxis(
+    p,
+    pre.backend,
+    "\u540E\u7AEF\u8BED\u8A00",
+    BACKEND_LANGUAGES,
+    OPTION_DEFAULTS.backend,
+    report,
+    "backend"
+  );
+  const frontend = await chooseAxis(
+    p,
+    pre.frontend,
+    "\u524D\u7AEF\u6846\u67B6",
+    FRONTEND_FRAMEWORKS,
+    OPTION_DEFAULTS.frontend,
+    report,
+    "frontend"
+  );
+  const mobile = await chooseAxis(
+    p,
+    pre.mobile,
+    "\u79FB\u52A8\u7AEF\uFF08\u624B\u673A\u539F\u751F\uFF09",
+    MOBILE_KINDS,
+    OPTION_DEFAULTS.mobile,
+    report,
+    "mobile"
+  );
+  const miniapp = await chooseAxis(
+    p,
+    pre.miniapp,
+    "\u5C0F\u7A0B\u5E8F",
+    MINIAPP_KINDS,
+    OPTION_DEFAULTS.miniapp,
+    report,
+    "miniapp"
+  );
+  const agent = await chooseAxis(
+    p,
+    pre.agent,
+    "\u7EC8\u7AEF/\u684C\u9762\u5BA2\u6237\u7AEF",
+    AGENT_KINDS,
+    OPTION_DEFAULTS.agent,
+    report,
+    "agent"
+  );
+  const deploy = await chooseAxis(
+    p,
+    pre.deploy,
+    "\u90E8\u7F72\u76EE\u6807",
+    DEPLOY_TARGETS,
+    OPTION_DEFAULTS.deploy,
+    report,
+    "deploy"
+  );
+  const contract = await chooseAxis(
+    p,
+    pre.contract,
+    "\u5951\u7EA6\u7C7B\u578B",
+    CONTRACT_KINDS,
+    OPTION_DEFAULTS.contract,
+    report,
+    "contract"
+  );
+  const ai = await chooseAxis(
+    p,
+    pre.ai,
+    "AI \u5DE5\u5177\u96C6\u6210",
+    AI_TOOLS,
+    OPTION_DEFAULTS.ai,
+    report,
+    "ai"
+  );
+  const license = await chooseAxis(
+    p,
+    pre.license,
+    "\u8BB8\u53EF\u8BC1",
+    LICENSE_KINDS,
+    OPTION_DEFAULTS.license,
+    report,
+    "license"
+  );
+  const gitLfs = pre.gitLfs ?? await p.confirm("\u542F\u7528 Git LFS \u7BA1\u7406\u5927\u6587\u4EF6", OPTION_DEFAULTS.gitLfs);
+  report("gitLfs", String(gitLfs), pre.gitLfs === void 0);
+  const integrations = pre.integrations ?? await p.confirm(
+    "\u751F\u6210 docs/06-\u96C6\u6210\u5BF9\u63A5/ \u9AA8\u67B6\uFF08\u5F53\u672C\u4ED3\u5E93\u7684\u67D0\u4E00\u7AEF\u9700\u8981\u4E0E\u5916\u90E8\u4ED3\u5E93\u5BF9\u63A5\u65F6\u542F\u7528\uFF09",
+    OPTION_DEFAULTS.integrations
+  );
+  report("integrations", String(integrations), pre.integrations === void 0);
+  const ci = await chooseAxis(
+    p,
+    pre.ci,
+    "CI \u5E73\u53F0",
+    CI_PLATFORMS,
+    OPTION_DEFAULTS.ci,
+    report,
+    "ci"
+  );
+  let roles;
+  if (pre.roles !== void 0) {
+    roles = pre.roles;
+    report("roles", roles.length > 0 ? roles.join(",") : "<none>", false);
+  } else {
+    const roleChoices = [
+      { value: "design", name: "design          UI / UX \u8BBE\u8BA1\u8D44\u6E90" },
+      { value: "qa", name: "qa              \u6D4B\u8BD5\u8BA1\u5212 / \u7528\u4F8B / \u7F3A\u9677\u5E93" },
+      { value: "field", name: "field           \u5BA2\u6237\u90E8\u7F72\u624B\u518C / \u4E0A\u7EBF\u4F5C\u4E1A\u4E66" },
+      { value: "data", name: "data            \u57CB\u70B9\u5951\u7EA6 / \u770B\u677F / \u6570\u636E\u8D44\u4EA7" },
+      { value: "legal-security", name: "legal-security  \u5408\u89C4\u6E05\u5355 / PIA / \u5B89\u5168\u8BC4\u4F30" },
+      { value: "marketing", name: "marketing       \u4EA7\u54C1\u4ECB\u7ECD / \u767D\u76AE\u4E66 / \u6848\u4F8B" }
+    ];
+    roles = await p.checkbox(
+      "\u542F\u7528\u54EA\u4E9B\u89D2\u8272\u76EE\u5F55\uFF1F\uFF08\u7A7A\u683C\u5207\u6362\uFF1B\u56DE\u8F66\u786E\u8BA4\uFF09",
+      roleChoices,
+      OPTION_DEFAULTS.roles
+    );
+    report("roles", roles.length > 0 ? roles.join(",") : "<none>", roles.length === 0);
+  }
+  return {
+    projectName,
+    backend,
+    frontend,
+    mobile,
+    miniapp,
+    agent,
+    deploy,
+    contract,
+    ai,
+    license,
+    gitLfs,
+    integrations,
+    ci,
+    roles
+  };
+}
+async function chooseAxis(prompter, prefilled, question, domain, def, report, axisName) {
+  if (prefilled !== void 0) {
+    report(axisName, prefilled, false);
+    return prefilled;
+  }
+  const value = await prompter.select(question, stringChoices(domain), def);
+  report(axisName, value, false);
+  return value;
+}
+
+// src/fragments/loader.ts
+import { promises as fs2, accessSync } from "node:fs";
+import * as path2 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/schema/manifest.ts
+import Ajv3 from "ajv";
+import { parse as parseYaml3, stringify as stringifyYaml } from "yaml";
+var SEMVER_PATTERN = "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z-.]+)?(?:\\+[0-9A-Za-z-.]+)?$";
+var FRAGMENT_NAME_PATTERN = "^[a-z0-9][a-z0-9-]{0,62}$";
+var POSIX_RELATIVE_PATH_PATTERN = "^(?!/)(?!.*(^|/)\\.\\.($|/))[^\\\\]+$";
+var MANIFEST_FILE_RULE_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["from", "to", "render"],
+  properties: {
+    from: { type: "string", minLength: 1, pattern: POSIX_RELATIVE_PATH_PATTERN },
+    to: { type: "string", minLength: 1, pattern: POSIX_RELATIVE_PATH_PATTERN },
+    render: { type: "boolean" },
+    mode: { type: "integer", minimum: 0, maximum: 4095 }
+  }
+};
+var APPLIES_WHEN_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    backend: { type: "string", enum: [...BACKEND_LANGUAGES] },
+    frontend: { type: "string", enum: [...FRONTEND_FRAMEWORKS] },
+    mobile: { type: "string", enum: [...MOBILE_KINDS] },
+    miniapp: { type: "string", enum: [...MINIAPP_KINDS] },
+    agent: { type: "string", enum: [...AGENT_KINDS] },
+    deploy: { type: "string", enum: [...DEPLOY_TARGETS] },
+    contract: { type: "string", enum: [...CONTRACT_KINDS] },
+    ai: { type: "string", enum: [...AI_TOOLS] },
+    license: { type: "string", enum: [...LICENSE_KINDS] },
+    gitLfs: { type: "boolean" },
+    integrations: { type: "boolean" },
+    ci: { type: "string", enum: [...CI_PLATFORMS] },
+    role: { type: "string", enum: [...ROLE_KINDS] }
+  }
+};
+var MANIFEST_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://cgsy.example.com/schemas/scaffolder/manifest.json",
+  title: "TemplateManifest",
+  type: "object",
+  additionalProperties: false,
+  required: ["name", "version", "appliesWhen", "priority", "files"],
+  properties: {
+    name: { type: "string", pattern: FRAGMENT_NAME_PATTERN },
+    version: { type: "string", pattern: SEMVER_PATTERN },
+    appliesWhen: APPLIES_WHEN_SCHEMA,
+    priority: { type: "integer", minimum: 0, maximum: 100 },
+    files: {
+      type: "array",
+      items: MANIFEST_FILE_RULE_SCHEMA
+    }
+  }
+};
+var ajv3 = new Ajv3({ allErrors: true, strict: true });
+var validateFn2 = ajv3.compile(MANIFEST_SCHEMA);
+var ManifestValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(
+      `Invalid TemplateManifest:
+` + issues.map((i) => `  - ${i.path || "<root>"}: ${i.message}`).join("\n")
+    );
+    this.name = "ManifestValidationError";
+    this.issues = issues;
+  }
+};
+function collectIssues2() {
+  const errs = validateFn2.errors ?? [];
+  return errs.map((e) => ({
+    path: e.instancePath || (e.params && "missingProperty" in e.params ? `/${String(e.params.missingProperty)}` : ""),
+    message: e.message ?? "validation error"
+  }));
+}
+function assertStructuralInvariants(m) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of m.files) {
+    if (seen.has(f.to)) {
+      throw new ManifestValidationError([
+        { path: "/files", message: `duplicate target path: ${f.to}` }
+      ]);
+    }
+    seen.add(f.to);
+  }
+}
+function assertManifest(value) {
+  if (!validateFn2(value)) {
+    throw new ManifestValidationError(collectIssues2());
+  }
+  assertStructuralInvariants(value);
+  return value;
+}
+function parseManifest(input) {
+  let raw;
+  const trimmed = input.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      raw = JSON.parse(trimmed);
+    } catch (e) {
+      throw new ManifestValidationError([
+        { path: "", message: `invalid JSON: ${e.message}` }
+      ]);
+    }
+  } else {
+    try {
+      raw = parseYaml3(input);
+    } catch (e) {
+      throw new ManifestValidationError([
+        { path: "", message: `invalid YAML: ${e.message}` }
+      ]);
+    }
+  }
+  return assertManifest(raw);
+}
+
+// src/fragments/loader.ts
+function defaultTemplatesRoot() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const pkgRoot = findPackageRoot(here);
+  return path2.join(pkgRoot, "src", "templates");
+}
+function findPackageRoot(start) {
+  let dir = start;
+  for (let i = 0; i < 10; i += 1) {
+    const candidate = path2.join(dir, "package.json");
+    try {
+      accessSync(candidate);
+      return dir;
+    } catch {
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new TemplateError(
+    `unable to locate package.json above ${start}`,
+    "\u8BF7\u786E\u8BA4 scaffolder \u4F5C\u4E3A npm \u5305\u5B89\u88C5\uFF0Csrc/templates/ \u4E0E package.json \u4F4D\u4E8E\u540C\u4E00\u5C42\u7EA7"
+  );
+}
+async function loadFragments(rootOverride) {
+  const templatesRoot = rootOverride ?? defaultTemplatesRoot();
+  let entries;
+  try {
+    const dirents = await fs2.readdir(templatesRoot, { withFileTypes: true });
+    entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch (e) {
+    throw new TemplateError(
+      `failed to read templates directory ${templatesRoot}: ${e.message}`,
+      "\u8BF7\u786E\u8BA4 scaffolder \u5B89\u88C5\u5B8C\u6574\uFF08src/templates/ \u5B58\u5728\uFF09"
+    );
+  }
+  const loaded = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const dir of entries.sort()) {
+    const fragmentDir = path2.join(templatesRoot, dir);
+    const manifestPath = path2.join(fragmentDir, "fragment.yaml");
+    let text;
+    try {
+      text = await fs2.readFile(manifestPath, "utf8");
+    } catch (e) {
+      throw new TemplateError(
+        `fragment "${dir}" is missing fragment.yaml: ${e.message}`,
+        "\u6BCF\u4E2A fragment \u76EE\u5F55\u5FC5\u987B\u5305\u542B fragment.yaml"
+      );
+    }
+    let manifest;
+    try {
+      manifest = parseManifest(text);
+    } catch (e) {
+      if (e instanceof ManifestValidationError) {
+        throw new TemplateError(
+          `fragment "${dir}" has invalid manifest:
+${e.message}`,
+          "\u6309 fragment.yaml schema \u4FEE\u590D\u5B57\u6BB5"
+        );
+      }
+      throw e;
+    }
+    if (manifest.name !== dir) {
+      throw new TemplateError(
+        `fragment directory "${dir}" declares name "${manifest.name}"`,
+        "\u76EE\u5F55\u540D\u4E0E manifest.name \u5FC5\u987B\u4E00\u81F4\uFF0C\u4FBF\u4E8E\u9759\u6001\u7D22\u5F15"
+      );
+    }
+    if (seenNames.has(manifest.name)) {
+      throw new TemplateError(
+        `duplicate fragment name: ${manifest.name}`,
+        "\u6BCF\u4E2A fragment \u540D\u79F0\u5728\u5168\u5C40\u5FC5\u987B\u552F\u4E00"
+      );
+    }
+    seenNames.add(manifest.name);
+    for (const file of manifest.files) {
+      const fromAbs = path2.join(fragmentDir, file.from);
+      try {
+        await fs2.access(fromAbs);
+      } catch {
+        throw new TemplateError(
+          `fragment "${manifest.name}" references missing file: ${file.from}`,
+          "\u8BF7\u786E\u8BA4 files/ \u4E2D\u5305\u542B\u8BE5\u6587\u4EF6\uFF0C\u6216\u4FEE\u6B63 manifest.files[].from"
+        );
+      }
+    }
+    loaded.push({ manifest, rootDir: fragmentDir });
+  }
+  return { templatesRoot, fragments: loaded };
+}
+
+// src/fragments/resolver.ts
+function fragmentApplies(manifest, options) {
+  return appliesWhenMatches(manifest.appliesWhen, options);
+}
+function appliesWhenMatches(appliesWhen, options) {
+  for (const key of Object.keys(appliesWhen)) {
+    const expected = appliesWhen[key];
+    if (expected === void 0) continue;
+    if (key === "role") {
+      if (!options.roles.includes(expected)) {
+        return false;
+      }
+      continue;
+    }
+    const actual = options[key];
+    if (actual !== expected) return false;
+  }
+  return true;
+}
+function selectFragments(options, loaded) {
+  const applicable = loaded.filter((f) => fragmentApplies(f.manifest, options));
+  return [...applicable].sort((a, b) => {
+    if (a.manifest.priority !== b.manifest.priority) {
+      return a.manifest.priority - b.manifest.priority;
+    }
+    return a.manifest.name.localeCompare(b.manifest.name);
+  });
+}
+
+// src/render/context.ts
+function buildRenderContext(input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  return {
+    options: input.options,
+    year: String(now.getUTCFullYear()),
+    generatedAt: now.toISOString(),
+    scaffolderVersion: input.scaffolderVersion
+  };
+}
+
+// src/plan/builder.ts
+import { promises as fs4 } from "node:fs";
+import * as path3 from "node:path";
+
+// src/render/renderer.ts
+import { Eta } from "eta";
+import { promises as fs3 } from "node:fs";
+function createEta() {
+  return new Eta({
+    autoEscape: false,
+    useWith: false,
+    cache: false,
+    autoTrim: false,
+    // Force tags to the explicit form to keep syntax unambiguous.
+    tags: ["<%", "%>"]
+  });
+}
+function toStrictContext(ctx) {
+  const base = {
+    options: ctx.options,
+    year: ctx.year,
+    generatedAt: ctx.generatedAt,
+    scaffolderVersion: ctx.scaffolderVersion
+  };
+  return new Proxy(base, {
+    get(target, prop, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (!(prop in target)) {
+        throw new TemplateError(
+          `undefined template variable: ${String(prop)}`,
+          "\u8BF7\u786E\u8BA4\u53D8\u91CF\u540D\u4E0E RenderContext \u5B57\u6BB5\u4E00\u81F4\uFF0C\u6216\u6269\u5C55 RenderContext"
+        );
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function rethrowRenderError(source, err) {
+  if (err instanceof TemplateError) throw err;
+  const message = err instanceof Error ? err.message : String(err);
+  throw new TemplateError(
+    `render failed in ${source}: ${message}`,
+    "\u68C0\u67E5\u6A21\u677F\u8BED\u6CD5\u662F\u5426\u4E0E <% %> \u6807\u7B7E\u4E00\u81F4"
+  );
+}
+function renderString(template, context, source = "<string>") {
+  const eta = createEta();
+  const strict = toStrictContext(context);
+  try {
+    const out = eta.renderString(template, strict);
+    if (typeof out !== "string") {
+      throw new TemplateError(
+        `renderer returned non-string for ${source}`,
+        "\u8FD9\u662F\u4E00\u4E2A scaffolder \u5185\u90E8\u9519\u8BEF\uFF0C\u8BF7\u6C47\u62A5"
+      );
+    }
+    return out;
+  } catch (err) {
+    rethrowRenderError(source, err);
+  }
+}
+async function renderFile(absPath, context) {
+  let text;
+  try {
+    text = await fs3.readFile(absPath, "utf8");
+  } catch (err) {
+    throw new TemplateError(
+      `failed to read template ${absPath}: ${err.message}`,
+      "\u8BF7\u786E\u8BA4 fragment.yaml \u4E2D\u7684 from \u8DEF\u5F84\u6307\u5411\u771F\u5B9E\u6587\u4EF6"
+    );
+  }
+  return renderString(text, context, absPath);
+}
+
+// src/plan/builder.ts
+async function buildFilePlan(input) {
+  const { fragments, context } = input;
+  const byPath = /* @__PURE__ */ new Map();
+  for (const fragment of fragments) {
+    for (const rule of fragment.manifest.files) {
+      const fromAbs = path3.join(fragment.rootDir, rule.from);
+      const targetPath = normalizePosixPath(rule.to);
+      let content;
+      if (rule.render) {
+        content = await renderFile(fromAbs, context);
+      } else {
+        try {
+          content = await fs4.readFile(fromAbs, "utf8");
+        } catch (e) {
+          throw new TemplateError(
+            `failed to read template source ${fromAbs}: ${e.message}`,
+            "\u8BF7\u786E\u8BA4 manifest.files[].from \u6307\u5411\u771F\u5B9E\u6587\u4EF6"
+          );
+        }
+      }
+      const candidate = {
+        targetPath,
+        content,
+        contributedBy: fragment.manifest.name,
+        ...rule.mode !== void 0 ? { mode: rule.mode } : {},
+        priority: fragment.manifest.priority
+      };
+      const existing = byPath.get(targetPath);
+      if (existing === void 0) {
+        byPath.set(targetPath, candidate);
+        continue;
+      }
+      if (candidate.priority > existing.priority) {
+        byPath.set(targetPath, candidate);
+      } else if (candidate.priority < existing.priority) {
+      } else if (existing.content !== candidate.content) {
+        throw new TemplateError(
+          `conflict at ${targetPath}: fragments "${existing.contributedBy}" and "${candidate.contributedBy}" have equal priority ${candidate.priority} but contribute different content`,
+          "\u8C03\u6574 fragment \u7684 priority\uFF0C\u6216\u7531\u4E00\u4E2A fragment \u72EC\u5360\u8BE5\u8DEF\u5F84"
+        );
+      }
+    }
+  }
+  const files = [...byPath.values()].map(({ priority: _p, ...rest }) => rest).sort((a, b) => a.targetPath < b.targetPath ? -1 : a.targetPath > b.targetPath ? 1 : 0);
+  const directorySet = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    let cur = path3.posix.dirname(f.targetPath);
+    while (cur && cur !== "." && cur !== "/") {
+      directorySet.add(cur);
+      cur = path3.posix.dirname(cur);
+    }
+  }
+  const directories = [...directorySet].sort();
+  return { files, directories };
+}
+function normalizePosixPath(p) {
+  return p.split(/[\\/]+/).filter(Boolean).join("/");
+}
+
+// src/plan/syntax.ts
+import { parse as parseYaml4 } from "yaml";
+function validatePlanSyntax(plan) {
+  for (const file of plan.files) {
+    const ext = lowerExt(file.targetPath);
+    if (ext === "json") {
+      try {
+        JSON.parse(file.content);
+      } catch (e) {
+        throw new TemplateError(
+          `invalid JSON in generated file ${file.targetPath} (from fragment ${file.contributedBy}): ${e.message}`,
+          "\u68C0\u67E5\u5BF9\u5E94\u6A21\u677F\u7684\u8BED\u6CD5"
+        );
+      }
+    } else if (ext === "yaml" || ext === "yml") {
+      try {
+        parseYaml4(file.content);
+      } catch (e) {
+        throw new TemplateError(
+          `invalid YAML in generated file ${file.targetPath} (from fragment ${file.contributedBy}): ${e.message}`,
+          "\u68C0\u67E5\u5BF9\u5E94\u6A21\u677F\u7684\u7F29\u8FDB\u4E0E\u5F15\u53F7"
+        );
+      }
+    }
+  }
+}
+function lowerExt(p) {
+  const dot = p.lastIndexOf(".");
+  if (dot < 0) return "";
+  return p.slice(dot + 1).toLowerCase();
+}
+
+// src/schema/metadata.ts
+import Ajv4 from "ajv";
+import addFormats2 from "ajv-formats";
+var METADATA_FILENAME = ".scaffolder.json";
+var SEMVER_PATTERN2 = "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z-.]+)?(?:\\+[0-9A-Za-z-.]+)?$";
+var FRAGMENT_NAME_PATTERN2 = "^[a-z0-9][a-z0-9-]{0,62}$";
+var METADATA_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://cgsy.example.com/schemas/scaffolder/metadata.json",
+  title: "ScaffolderMetadata",
+  type: "object",
+  additionalProperties: false,
+  required: ["scaffolderVersion", "generatedAt", "options", "templateFragments"],
+  properties: {
+    scaffolderVersion: { type: "string", pattern: SEMVER_PATTERN2 },
+    generatedAt: { type: "string", format: "date-time" },
+    options: OPTIONS_SCHEMA,
+    templateFragments: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["name", "version"],
+        properties: {
+          name: { type: "string", pattern: FRAGMENT_NAME_PATTERN2 },
+          version: { type: "string", pattern: SEMVER_PATTERN2 }
+        }
+      }
+    }
+  }
+};
+var ajv4 = new Ajv4({ allErrors: true, strict: true });
+addFormats2(ajv4);
+var validateFn3 = ajv4.compile(METADATA_SCHEMA);
+var METADATA_TOP_ORDER = [
+  "scaffolderVersion",
+  "generatedAt",
+  "options",
+  "templateFragments"
+];
+function canonicalOptions(options) {
+  const out = {};
+  for (const key of OPTIONS_FIELD_ORDER) {
+    out[key] = options[key];
+  }
+  return out;
+}
+function canonicalFragmentRef(ref) {
+  return { name: ref.name, version: ref.version };
+}
+function canonicalMetadata(metadata) {
+  const out = {};
+  for (const key of METADATA_TOP_ORDER) {
+    if (key === "options") {
+      out[key] = canonicalOptions(metadata.options);
+    } else if (key === "templateFragments") {
+      out[key] = metadata.templateFragments.map(canonicalFragmentRef);
+    } else {
+      out[key] = metadata[key];
+    }
+  }
+  return out;
+}
+function serializeMetadata(metadata) {
+  return JSON.stringify(canonicalMetadata(metadata), null, 2) + "\n";
+}
+function buildMetadata(params) {
+  const now = params.now ?? /* @__PURE__ */ new Date();
+  return {
+    scaffolderVersion: params.scaffolderVersion,
+    generatedAt: now.toISOString(),
+    options: params.options,
+    templateFragments: [...params.templateFragments]
+  };
+}
+
+// src/plan/metadata.ts
+function appendScaffolderMetadata(input) {
+  const metadata = buildMetadata({
+    scaffolderVersion: input.scaffolderVersion,
+    options: input.options,
+    templateFragments: input.templateFragments,
+    ...input.now !== void 0 ? { now: input.now } : {}
+  });
+  const file = {
+    targetPath: METADATA_FILENAME,
+    content: serializeMetadata(metadata),
+    contributedBy: "__scaffolder_metadata__"
+  };
+  const files = [...input.plan.files, file].sort(
+    (a, b) => a.targetPath < b.targetPath ? -1 : a.targetPath > b.targetPath ? 1 : 0
+  );
+  return { files, directories: input.plan.directories };
+}
+
+// src/writer/writer.ts
+import { promises as fs5 } from "node:fs";
+import * as path4 from "node:path";
+var FORCE_BACKUP_BYTE_LIMIT = 10 * 1024 * 1024;
+async function writePlan(plan, opts) {
+  const absTarget = path4.resolve(opts.targetDirectory);
+  const journal = { createdFiles: [], createdDirectories: [], overwrites: [] };
+  const targetState = await inspectTarget(absTarget);
+  if (targetState.exists && targetState.nonEmpty && !opts.force) {
+    throw new UserInputError(
+      `target directory is not empty: ${absTarget}`,
+      "\u4F7F\u7528\u4E0D\u540C\u8DEF\u5F84\uFF0C\u6216\u52A0 --force\uFF08\u5C0F\u5FC3\uFF1A\u4F1A\u8986\u76D6\u65E2\u6709\u6587\u4EF6\uFF09"
+    );
+  }
+  if (opts.force && targetState.exists) {
+    await preflightBackupCapacity(absTarget, plan);
+  }
+  try {
+    if (!targetState.exists) {
+      await fs5.mkdir(absTarget, { recursive: true });
+      journal.createdDirectories.push(absTarget);
+    }
+    for (const rel of plan.directories) {
+      const abs = path4.join(absTarget, rel);
+      try {
+        await fs5.mkdir(abs);
+        journal.createdDirectories.push(abs);
+      } catch (err) {
+        if (err.code === "EEXIST") {
+          continue;
+        }
+        throw err;
+      }
+    }
+    for (const file of plan.files) {
+      const abs = path4.join(absTarget, file.targetPath);
+      await fs5.mkdir(path4.dirname(abs), { recursive: true });
+      if (opts.force) {
+        try {
+          const prev = await fs5.readFile(abs, "utf8");
+          journal.overwrites.push({ absPath: abs, originalContent: prev });
+        } catch {
+        }
+      }
+      await fs5.writeFile(abs, file.content, "utf8");
+      if (file.mode !== void 0) {
+        await fs5.chmod(abs, file.mode);
+      }
+      journal.createdFiles.push(abs);
+    }
+    return {
+      createdFiles: journal.createdFiles,
+      createdDirectories: journal.createdDirectories
+    };
+  } catch (err) {
+    await rollback(journal);
+    if (err instanceof UserInputError) throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new FilesystemError(
+      `file writer failed; changes rolled back: ${message}`,
+      "\u68C0\u67E5\u6743\u9650\u4E0E\u78C1\u76D8\u7A7A\u95F4\uFF0C\u5FC5\u8981\u65F6\u5220\u9664\u6B8B\u7559\u76EE\u5F55\u540E\u91CD\u8BD5"
+    );
+  }
+}
+async function inspectTarget(absTarget) {
+  try {
+    const entries = await fs5.readdir(absTarget);
+    return { exists: true, nonEmpty: entries.length > 0 };
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return { exists: false, nonEmpty: false };
+    throw new FilesystemError(
+      `cannot inspect target directory ${absTarget}: ${err.message}`,
+      "\u68C0\u67E5\u8DEF\u5F84\u7684\u8BBF\u95EE\u6743\u9650"
+    );
+  }
+}
+async function preflightBackupCapacity(absTarget, plan) {
+  for (const file of plan.files) {
+    const abs = path4.join(absTarget, file.targetPath);
+    try {
+      const stat = await fs5.stat(abs);
+      if (stat.isFile() && stat.size > FORCE_BACKUP_BYTE_LIMIT) {
+        throw new UserInputError(
+          `--force would overwrite ${abs} which is larger than the 10 MB rollback limit`,
+          "\u624B\u52A8\u5907\u4EFD / \u5220\u9664\u8BE5\u6587\u4EF6\u540E\u91CD\u8BD5"
+        );
+      }
+    } catch (err) {
+      if (err.code === "ENOENT") continue;
+      if (err instanceof UserInputError) throw err;
+      throw new UserInputError(
+        `cannot inspect existing file ${abs}: ${err.message}`,
+        "\u8BF7\u786E\u8BA4\u76EE\u6807\u76EE\u5F55\u4E0B\u6240\u6709\u6587\u4EF6\u53EF\u8BFB"
+      );
+    }
+  }
+}
+async function rollback(journal) {
+  for (let i = journal.overwrites.length - 1; i >= 0; i -= 1) {
+    const { absPath, originalContent } = journal.overwrites[i];
+    try {
+      await fs5.writeFile(absPath, originalContent, "utf8");
+    } catch {
+    }
+  }
+  const overwriteSet = new Set(journal.overwrites.map((o) => o.absPath));
+  for (let i = journal.createdFiles.length - 1; i >= 0; i -= 1) {
+    const p = journal.createdFiles[i];
+    if (overwriteSet.has(p)) continue;
+    try {
+      await fs5.rm(p, { force: true });
+    } catch {
+    }
+  }
+  for (let i = journal.createdDirectories.length - 1; i >= 0; i -= 1) {
+    const dir = journal.createdDirectories[i];
+    try {
+      await fs5.rmdir(dir);
+    } catch {
+    }
+  }
+}
+
+// src/reporter.ts
+var Reporter = class {
+  constructor(io, verbosity) {
+    this.io = io;
+    this.verbosity = verbosity;
+  }
+  stage(label) {
+    if (this.verbosity === "quiet") return;
+    this.io.stdout(`
+\u2500\u2500\u2500 ${label} \u2500\u2500\u2500`);
+  }
+  info(line) {
+    if (this.verbosity === "quiet") return;
+    this.io.stdout(line);
+  }
+  verbose(line) {
+    if (this.verbosity !== "verbose") return;
+    this.io.stdout(line);
+  }
+  options(options) {
+    if (this.verbosity === "quiet") return;
+    this.io.stdout(`  projectName: ${options.projectName}`);
+    this.io.stdout(`  backend:     ${options.backend}`);
+    this.io.stdout(`  frontend:    ${options.frontend}`);
+    this.io.stdout(`  mobile:      ${options.mobile}`);
+    this.io.stdout(`  miniapp:     ${options.miniapp}`);
+    this.io.stdout(`  agent:       ${options.agent}`);
+    this.io.stdout(`  deploy:      ${options.deploy}`);
+    this.io.stdout(`  contract:    ${options.contract}`);
+    this.io.stdout(`  ai:          ${options.ai}`);
+    this.io.stdout(`  license:     ${options.license}`);
+    this.io.stdout(`  gitLfs:      ${String(options.gitLfs)}`);
+    this.io.stdout(`  integrations: ${String(options.integrations)}`);
+    this.io.stdout(`  ci:          ${options.ci}`);
+    this.io.stdout(`  roles:       ${options.roles.length > 0 ? options.roles.join(",") : "<none>"}`);
+  }
+  dryRunReport(plan) {
+    this.io.stdout("\n[dry-run] would create the following files:");
+    for (const f of plan.files) {
+      const bytes = Buffer.byteLength(f.content, "utf8");
+      this.io.stdout(`  ${f.targetPath}  (${bytes} bytes, from ${f.contributedBy})`);
+    }
+    this.io.stdout(`
+[dry-run] total: ${plan.files.length} file(s)`);
+  }
+  writeProgress(file) {
+    if (this.verbosity !== "verbose") return;
+    const bytes = Buffer.byteLength(file.content, "utf8");
+    this.io.stdout(`  wrote ${file.targetPath}  (${bytes}B, from ${file.contributedBy})`);
+  }
+  summary(kind, fileCount, targetDir) {
+    if (kind === "created") {
+      this.io.stdout(`\u2713 created ${fileCount} file(s) at ${targetDir}`);
+    } else {
+      this.io.stdout(`\u2713 dry-run: ${fileCount} file(s) would be created at ${targetDir}`);
+    }
+  }
+};
+function verbosityFromFlags(flags) {
+  if (flags.quiet && flags.verbose) return "verbose";
+  if (flags.quiet) return "quiet";
+  if (flags.verbose) return "verbose";
+  return "default";
+}
+
+// src/orchestrator.ts
+async function runCreate(input) {
+  const reporter = new Reporter(
+    { stdout: input.io.stdout, stderr: input.io.stderr },
+    verbosityFromFlags(input.flags)
+  );
+  reporter.stage("options");
+  const options = await resolveOptions(input);
+  reporter.options(options);
+  reporter.stage("templates");
+  const { fragments } = await loadFragments(input.io.templatesRoot);
+  const selected = selectFragments(options, fragments);
+  reporter.info(`selected ${selected.length} fragment(s)`);
+  for (const f of selected) {
+    reporter.verbose(`  ${f.manifest.name}@${f.manifest.version} (priority ${f.manifest.priority})`);
+  }
+  reporter.stage("plan");
+  const context = buildRenderContext({
+    options,
+    scaffolderVersion: SCAFFOLDER_VERSION,
+    ...input.io.now !== void 0 ? { now: input.io.now } : {}
+  });
+  let plan = await buildFilePlan({ fragments: selected, context });
+  const fragmentRefs = selected.map((f) => ({
+    name: f.manifest.name,
+    version: f.manifest.version
+  }));
+  plan = appendScaffolderMetadata({
+    plan,
+    scaffolderVersion: SCAFFOLDER_VERSION,
+    options,
+    templateFragments: fragmentRefs,
+    ...input.io.now !== void 0 ? { now: input.io.now } : {}
+  });
+  validatePlanSyntax(plan);
+  reporter.info(`planned ${plan.files.length} file(s) across ${plan.directories.length} directory`);
+  const cwd = input.io.cwd ?? process.cwd();
+  const targetDirectory = path5.resolve(cwd, options.projectName);
+  if (input.flags.dryRun) {
+    reporter.stage("dry-run");
+    reporter.dryRunReport(plan);
+    reporter.summary("dry-run", plan.files.length, targetDirectory);
+    return { options, targetDirectory, fileCount: plan.files.length, dryRun: true };
+  }
+  reporter.stage("write");
+  const result = await writePlan(plan, { targetDirectory, force: input.flags.force ?? false });
+  for (const f of plan.files) {
+    reporter.writeProgress(f);
+  }
+  reporter.info(`wrote ${result.createdFiles.length} file(s)`);
+  reporter.summary("created", result.createdFiles.length, targetDirectory);
+  return {
+    options,
+    targetDirectory,
+    fileCount: result.createdFiles.length,
+    dryRun: false
+  };
+}
+async function resolveOptions(input) {
+  const { projectName, flags, io } = input;
+  let merged = {};
+  if (flags.config !== void 0) {
+    merged = { ...merged, ...await loadConfigFile(flags.config) };
+  }
+  merged = {
+    ...merged,
+    projectName,
+    ...flags.ci !== void 0 ? { ci: flags.ci } : {},
+    ...flags.roles !== void 0 ? { roles: flags.roles } : {}
+  };
+  if (flags.yes) {
+    const full = { ...buildDefaultOptions(projectName), ...merged };
+    return assertOptions(full);
+  }
+  if (!io.isTTY) {
+    throw new UserInputError(
+      "no TTY available and neither --yes nor a complete --config was provided",
+      "\u5728\u975E\u4EA4\u4E92\u73AF\u5883\u4E0B\u8BF7\u4F7F\u7528 --yes \u6216\u63D0\u4F9B\u5B8C\u6574\u7684 --config"
+    );
+  }
+  const prompter = io.prompter ?? new InquirerPrompter();
+  const prompted = await promptForOptions({
+    prompter,
+    prefilled: merged,
+    isTTY: io.isTTY,
+    report: (axis, value, usedDefault) => {
+      if (!flags.quiet && usedDefault) {
+        io.stdout(`  ${axis}: ${value}  (default)`);
+      } else if (flags.verbose) {
+        io.stdout(`  ${axis}: ${value}`);
+      }
+    }
+  });
+  return assertOptions(prompted);
+}
+
+// src/index.ts
+async function handleCreate(input) {
+  await runCreate({
+    projectName: input.projectName,
+    flags: input.flags,
+    io: {
+      stdout: (line) => {
+        console.log(line);
+      },
+      stderr: (line) => {
+        console.error(line);
+      },
+      isTTY: Boolean(process.stdout.isTTY)
+    }
+  });
+}
+var exitCode = await run({
+  argv: process.argv,
+  stdout: (line) => {
+    console.log(line);
+  },
+  stderr: (line) => {
+    console.error(line);
+  },
+  onCreate: handleCreate
+});
+process.exit(exitCode);
+//# sourceMappingURL=index.js.map