@lingfan-engine/create 0.3.4 → 0.3.5

package/src/cli/prompts.ts

@@ -1,31 +1,43 @@
 /**
  * 交互问答。
  *
- * 生成器要问三件事：工程名、框架、壳。故事源形态不再是问题——骨架自带整条 TS
- * 创作链，它就是缺省形态；要手艺写的 `.story` 用 `--sources story` 指定即可。
+ * 生成器按固定顺序问三件事：工程名 → 描述 → 形态。顺序不能换：工程名决定目录与
+ * 包名，描述与形态都是在「这个工程」之上的补充；先问后者再问名字，人得回头改口。
+ *
+ * 形态是**一次多选**而不是三个单选：可叠加的层是一张网，不是三根互不相干的轴——
+ * 选 Vue 就排除了小程序，选桌面壳又与小程序互斥。逐个维度问会把矛盾留到最后才
+ * 暴露，一次问清则当场说穿重问。
  *
  * 目标目录非空时另问一次怎么处置：那是覆盖别人的东西，必须由使用者当场表态，
  * 不能拿缺省值糊过去（缺省是取消）。
  *
  * 实现只用 `node:readline` 的 promise 版：它随 Node 自带，不引第三方交互库。
- * 提问写 stderr 而不是 stdout，产物路径之类的结果才走 stdout，这样
- * `npm create … > log.txt` 不会把问题一起吞掉。
+ * 提问写 stderr 而不是 stdout，这样 `npm create … > log.txt` 不会把问题一起吞掉。
  */
 import { createInterface } from "node:readline/promises";
-import { isValidProjectName, suggestProjectName } from "../shared/index.ts";
-import type { TemplateOption } from "../registry/index.ts";
+import {
+  isValidProjectName,
+  normalizeDescription,
+  suggestProjectName,
+} from "../shared/index.ts";
+import type { LayerConflict, TemplateOption } from "../registry/index.ts";
 import type { ExistingTarget } from "../generate/index.ts";
 
 /** 问答需要的一份文案；由调用方从共享文案表传入，便于测试替换 */
 export interface PromptTexts {
   readonly promptProjectName: string;
-  readonly promptFramework: string;
-  readonly promptShell: string;
+  readonly promptDescription: string;
+  readonly descriptionHint: string;
+  readonly promptLayers: string;
+  readonly nonInteractive: string;
+  readonly nonInteractiveHint: string;
   readonly promptExisting: string;
   readonly nameRequired: string;
   readonly nameInvalid: string;
-  readonly frameworkUnknown: string;
-  readonly shellUnknown: string;
+  readonly layersEmptyHint: string;
+  readonly layersInvalid: string;
+  readonly layersConflict: string;
+  readonly layersConflictHint: string;
   readonly existingIgnore: string;
   readonly existingIgnoreHint: string;
   readonly existingClear: string;
@@ -40,15 +52,48 @@ export interface PromptIo {
   close(): void;
 }
 
-/** 造一个接到标准输入输出的问答面 */
-export function createTerminalIo(): PromptIo {
+/** 输入已关闭时的失败信息：调用方会把它印出来并退出，因此要人读得懂 */
+const INPUT_CLOSED = "标准输入已关闭，无法继续问答";
+
+/**
+ * 造一个接到标准输入输出的问答面。
+ *
+ * 参数是为了可测：非交互终端下 `question()` 必须失败而不是永远挂着。`readline` 在
+ * 输入流结束后只会发一个 `close` 事件，它自己的 promise 因此既不 resolve 也不
+ * reject——进程于是停在「等一个永远不会到的回车」，靠外部超时才退出。这里把
+ * `close` 转成 reject，让失败变成一次可捕获的异常。
+ */
+export function createTerminalIo(
+  input: NodeJS.ReadableStream = process.stdin,
+  output: NodeJS.WritableStream = process.stderr,
+): PromptIo {
   const rl = createInterface({
-    input: process.stdin,
-    output: process.stderr,
-    terminal: process.stdin.isTTY === true,
+    input,
+    output,
+    terminal: input === process.stdin && process.stdin.isTTY === true,
+  });
+  let closed = false;
+  rl.once("close", () => {
+    closed = true;
   });
   return {
-    question: (text) => rl.question(text),
+    question: (text) => {
+      if (closed) return Promise.reject(new Error(INPUT_CLOSED));
+      return new Promise<string>((resolve, reject) => {
+        const fail = (): void => reject(new Error(INPUT_CLOSED));
+        rl.once("close", fail);
+        rl.question(text).then(
+          (answer) => {
+            rl.off("close", fail);
+            resolve(answer);
+          },
+          (error: unknown) => {
+            rl.off("close", fail);
+            reject(error instanceof Error ? error : new Error(String(error)));
+          },
+        );
+      });
+    },
     close: () => rl.close(),
   };
 }
@@ -76,30 +121,69 @@ export async function askProjectName(
 }
 
 /**
- * 从选项表里选一项：输入序号（从 1 起）或直接输入 id，空输入取首项。
+ * 问描述：只问一次，回车即空。
  *
- * 两种取值都认，是因为脚本里写 `--framework vue` 更自然，而交互时按数字更省事；
- * 让同一套问答支持两种输入，参数模式与交互模式就不必分两套校验。
+ * 不重问也不校验：描述只影响清单里的一行说明，不影响任何路径与命令。为难一个
+ * 可以留空的输入框，只会让人多点几次回车。超长按上限截断——`package.json` 的
+ * 描述在工具链里本就是短文本，与其被别处悄悄截，不如自己截。
  */
-export async function askOption(
+export async function askDescription(
   io: PromptIo,
-  label: string,
-  options: readonly TemplateOption[],
-  fallbackId: string | undefined,
-  invalidText: string,
+  texts: PromptTexts,
 ): Promise<string> {
-  if (fallbackId !== undefined) return fallbackId;
-  const lines = options
-    .map((option, index) => `  ${index + 1}. ${option.label} —— ${option.hint}`)
+  const answer = await io.question(
+    `${texts.promptDescription}（${texts.descriptionHint}）：`,
+  );
+  return normalizeDescription(answer);
+}
+
+/**
+ * 问形态：一次多选，空格或逗号分隔，回车即空集。
+ *
+ * 选项表由调用方按「这一层有没有目录」筛过，所以这里看不到 `none`/`browser`/`ts`
+ * 这类缺省层——它们不是一个可以叠加的东西，而是「什么都不叠」。
+ *
+ * 互斥对由元数据的 `excludes` 推导，本文件不认识任何具体层 id：新增一层只要在
+ * 元数据里声明互斥，问答自动跟着变。撞上互斥就说穿是哪两层、然后重问同一问，
+ * 不静默丢掉其中一层——丢掉会让「我明明选了小程序」无法解释。
+ */
+export async function askLayers(
+  io: PromptIo,
+  texts: PromptTexts,
+  layers: readonly TemplateOption[],
+  catalogue: readonly TemplateOption[],
+): Promise<string[]> {
+  const labels = new Map(catalogue.map((option) => [option.id, option.label]));
+  const lines = layers
+    .map((option, index) => {
+      const excludes = (option.excludes ?? []).map(
+        (id) => labels.get(id) ?? id,
+      );
+      const tail =
+        excludes.length > 0 ? `  互斥：${excludes.join("、")}` : "  互斥：无";
+      return `  ${index + 1}. ${option.label} —— ${option.hint}${tail}`;
+    })
     .join("\n");
-  process.stderr.write(`${label}：\n${lines}\n`);
+  process.stderr.write(`${texts.promptLayers}：\n${lines}\n`);
   for (;;) {
     const answer = (
-      await io.question(`选择（1-${options.length}，回车取 1）：`)
+      await io.question(
+        `选择（1-${layers.length}，可多选，空格或逗号分隔；${texts.layersEmptyHint}）：`,
+      )
     ).trim();
-    const picked = pickOption(options, answer);
-    if (picked !== undefined) return picked;
-    process.stderr.write(`${invalidText}\n`);
+    const picked = parseLayerAnswer(layers, answer);
+    if (picked === undefined) {
+      process.stderr.write(`${texts.layersInvalid}\n`);
+      continue;
+    }
+    const conflicts = findLayerConflicts(picked, catalogue);
+    if (conflicts.length === 0) return picked;
+    for (const [left, right] of conflicts) {
+      process.stderr.write(
+        `${texts.layersConflict}：${labels.get(left) ?? left} 与 ${labels.get(right) ?? right} 不能共存\n`,
+      );
+    }
+    process.stderr.write(`${texts.layersConflictHint}：`);
   }
 }
 
@@ -162,3 +246,71 @@ export function pickOption(
   }
   return undefined;
 }
+
+/**
+ * 把一次多选输入解析成层 id 列表，保序去重；有认不出的编号或名字时返回 undefined。
+ *
+ * 认两种写法（序号与 id）是为了脚本与手敲都顺手；认空格、半角逗号与全角逗号是因为
+ * 中文输入法下逗号常常是全角的，为这个报错只会让人困惑。
+ *
+ * 空输入是空集而**不是**错误：不选任何层就是「只用骨架」，那是最常见的形态。
+ */
+export function parseLayerAnswer(
+  layers: readonly TemplateOption[],
+  answer: string,
+): string[] | undefined {
+  const tokens = answer
+    .split(/[\s,，]+/)
+    .map((token) => token.trim())
+    .filter((token) => token !== "");
+  if (tokens.length === 0) return [];
+  const out: string[] = [];
+  for (const token of tokens) {
+    const picked = pickOptionStrict(layers, token);
+    if (picked === undefined) return undefined;
+    if (!out.includes(picked)) out.push(picked);
+  }
+  return out;
+}
+
+/**
+ * 从选中的层里找出互斥对。
+ *
+ * 只看「选中的这两层彼此排斥」，不看谁先声明的：`excludes` 单边声明即生效，
+ * 因此两边都写了也只算一对。
+ */
+export function findLayerConflicts(
+  selected: readonly string[],
+  catalogue: readonly TemplateOption[],
+): LayerConflict[] {
+  const chosen = new Set(selected);
+  const seen = new Set<string>();
+  const out: LayerConflict[] = [];
+  for (const option of catalogue) {
+    if (!chosen.has(option.id)) continue;
+    for (const excluded of option.excludes ?? []) {
+      if (!chosen.has(excluded)) continue;
+      const key = [option.id, excluded].sort().join("\u0000");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push([option.id, excluded]);
+    }
+  }
+  return out;
+}
+
+/** 与 `pickOption` 同义，但不把空输入当首项：多选里空输入是「什么都不选」 */
+function pickOptionStrict(
+  options: readonly TemplateOption[],
+  token: string,
+): string | undefined {
+  if (token === "") return undefined;
+  const index = Number(token);
+  if (Number.isInteger(index) && index >= 1 && index <= options.length) {
+    return options[index - 1].id;
+  }
+  for (const option of options) {
+    if (option.id === token) return option.id;
+  }
+  return undefined;
+}

package/src/cli/stage.ts

@@ -0,0 +1,113 @@
+/**
+ * 生成阶段：查版本 → 写文件 → 可选安装 → 打印后续步骤。
+ *
+ * 为什么与参数解析分开：这一段对使用者是「正在干活」的进度叙事，对测试是纯副作用，
+ * 而参数解析是纯函数。两者放在一个文件里，任何一边的改动都要重新读另一边的代码。
+ *
+ * 入参自带形状而不复用命令行类型：本文件不需要知道参数是怎么解析出来的，只认得
+ * 「要生成什么」。这也让方向保持单向——参数层依赖这里，这里不回头依赖参数层。
+ */
+import { resolve as resolvePath } from "node:path";
+import { currentPackageManager, defaultCreateTexts } from "../shared/index.ts";
+import {
+  collectDependencyNames,
+  generateProject,
+  layerBases,
+  type ExistingTarget,
+} from "../generate/index.ts";
+import {
+  checkEngineCompatibility,
+  resolveVersions,
+  type TemplateMeta,
+} from "../registry/index.ts";
+import { installProject, renderNextSteps } from "./install.ts";
+
+/** 生成阶段需要的信息；`description` 为空串表示产物里不出现该字段 */
+export interface StageOptions {
+  readonly meta: TemplateMeta;
+  readonly templateRoot: string;
+  /** 生成到哪个目录下；缺省为当前目录 */
+  readonly dir: string | undefined;
+  readonly projectName: string;
+  readonly description: string;
+  readonly framework: string;
+  readonly shell: string;
+  readonly sources: string;
+  readonly existing: ExistingTarget;
+  readonly install: boolean;
+}
+
+/**
+ * 执行一次生成，返回进程退出码。
+ *
+ * 版本查询与兼容性判定都排在写盘之前：模板要求的引擎还没发布时，生成出来的工程
+ * 装不上，让它失败在「什么都没写」的时刻，而不是在别人的工程里第一次启动时。
+ */
+export async function runStage(options: StageOptions): Promise<number> {
+  const texts = defaultCreateTexts;
+  const manager = currentPackageManager();
+  const targetBase = resolvePath(options.dir ?? process.cwd());
+  const layout = {
+    templateRoot: options.templateRoot,
+    targetBase,
+    projectName: options.projectName,
+    description: options.description,
+    framework: options.framework,
+    shell: options.shell,
+    sources: options.sources,
+    resolved: new Map<string, string>(),
+  };
+
+  process.stderr.write(`${texts.stageResolve}\n`);
+  const names = collectDependencyNames(layerBases(layout));
+  const resolved = await resolveVersions(names);
+  if (resolved.size === 0 && names.length > 0) {
+    process.stderr.write(`${texts.warnVersionOffline}\n`);
+  }
+  const incompatible = checkEngineCompatibility(
+    options.meta.minEngineVersion,
+    resolved,
+  );
+  if (incompatible !== undefined) {
+    process.stderr.write(`${incompatible}\n`);
+    return 1;
+  }
+
+  process.stderr.write(`${texts.stageCopy}\n`);
+  let result;
+  try {
+    result = generateProject({
+      ...layout,
+      existing: options.existing,
+      resolved,
+    });
+  } catch (error) {
+    process.stderr.write(`${describe(error)}\n`);
+    return 1;
+  }
+
+  let installed = false;
+  if (options.install) {
+    process.stderr.write(`${texts.stageInstall}\n`);
+    installed = await installProject(result.projectDir, manager);
+    if (!installed) process.stderr.write(`${texts.warnInstallFailed}\n`);
+  }
+
+  process.stdout.write(
+    [
+      "",
+      `${texts.doneTitle}：${result.projectDir}`,
+      `共 ${result.fileCount} 个文件，框架 ${result.framework}，壳 ${result.shell}，故事源 ${result.sources}`,
+      "",
+      installed ? "依赖已安装。" : "依赖未安装。",
+      renderNextSteps(result.projectDir, manager, texts),
+      "",
+    ].join("\n"),
+  );
+  return 0;
+}
+
+/** 把异常折成一行提示：只暴露信息，不暴露堆栈 */
+function describe(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/generate/project.ts

@@ -61,6 +61,13 @@ export interface GenerateOptions {
    * 可选是为了不破坏既有调用方——只关心框架与壳的代码不必为一个用不到的参数改签名。
    */
   readonly sources?: string;
+  /**
+   * 工程描述；写进 `package.json` 与 `Resources/project.json` 两处。
+   *
+   * 缺省与空串都表示「没有描述」，两处清单里都不出现该键。这两种状态不做区分：
+   * 调用方要么知道有描述，要么什么都没说，第三种「有但是空」没有语义。
+   */
+  readonly description?: string;
   /** 目标目录非空时怎么办；缺省 `cancel`（报错退出，不碰磁盘） */
   readonly existing?: ExistingTarget;
   /** 引擎包的最新版本；缺席项沿用模板记录的值 */
@@ -111,13 +118,16 @@ export function generateProject(options: GenerateOptions): GenerateResult {
     }
   }
   const merged = mergeLayers(layerBases(options));
-  const files = finalize(
-    merged.files,
-    merged.patch,
-    merged.pinned,
-    options.resolved,
-    meta.placeholder,
-    options.projectName,
+  const files = applyDescription(
+    finalize(
+      merged.files,
+      merged.patch,
+      merged.pinned,
+      options.resolved,
+      meta.placeholder,
+      options.projectName,
+    ),
+    options.description ?? "",
   );
   mkdirSync(projectDir, { recursive: true });
   for (const file of files) {
@@ -234,6 +244,47 @@ export function finalize(
   });
 }
 
+/**
+ * 把工程描述写进两份清单。
+ *
+ * 写两处是因为它们服务不同读者：`package.json` 是开发者与 npm 工具链的门面，
+ * `Resources/project.json` 跟资源一起走，运行时与构建期都读它。同源同值，
+ * 由同一个变量一次写入，不会出现两处说法不一致。
+ *
+ * 没有描述时**一个字节都不改**：模板里本就不写这个键，于是「没填描述」的产物
+ * 与引入描述之前逐字节一致，也不存在「空描述」这种中间状态。
+ */
+function applyDescription(
+  files: readonly PendingFile[],
+  description: string,
+): PendingFile[] {
+  if (description === "") return [...files];
+  return files.map((file) => {
+    if (!MANIFEST_WITH_DESCRIPTION.has(file.path)) return file;
+    const manifest = JSON.parse(file.content.toString("utf8")) as Record<
+      string,
+      unknown
+    >;
+    return {
+      path: file.path,
+      content: Buffer.from(
+        `${JSON.stringify({ ...manifest, description }, null, 2)}\n`,
+        "utf8",
+      ),
+    };
+  });
+}
+
+/**
+ * 描述落点的产物路径。
+ *
+ * 用产物路径而不是模板路径判断：点文件还原已经发生，这里的取值就是最终写盘的名字。
+ */
+const MANIFEST_WITH_DESCRIPTION: ReadonlySet<string> = new Set([
+  "package.json",
+  "Resources/project.json",
+]);
+
 /**
  * 把增量与版本号写进 `package.json`。
  *

package/src/registry/index.ts

@@ -1,10 +1,14 @@
 /** registry 域唯一出口：模板元数据定位 + npm 版本查询 + 引擎兼容判定。 */
 export { checkEngineCompatibility, ENGINE_SCOPE } from "./compat.ts";
 export {
+  existsLayerDirectory,
+  findConflicts,
   overlayDirOf,
   readTemplateMeta,
   resolveTemplateRoot,
+  selectableLayers,
   OVERLAY_DIR,
+  type LayerConflict,
   type TemplateMeta,
   type TemplateOption,
 } from "./template-meta.ts";

package/src/registry/template-meta.ts

@@ -41,6 +41,13 @@ export interface TemplateOption {
   readonly label: string;
   /** 一句话说明，交互问答里作为提示 */
   readonly hint: string;
+  /**
+   * 不能与本层共存的其他层 id；缺省视为空数组。
+   *
+   * 元素是**跨维度**的层 id（框架可以排斥壳），不是同一维度内的兄弟项。
+   * 单边声明即生效：只要一对层里有一方点名了另一方，这一对就是互斥的。
+   */
+  readonly excludes?: readonly string[];
 }
 
 /**
@@ -115,3 +122,69 @@ export function overlayDirOf(
   const dir = join(templateRoot, OVERLAY_DIR, optionId);
   return existsSync(dir) ? dir : undefined;
 }
+
+/**
+ * 这一层是否有自己的目录。
+ *
+ * 判据是磁盘事实而不是 id 白名单：新增一层只要建了目录就自动可选，删掉目录就自动
+ * 退出选项面，生成器不必跟着改。缺省项（`none`/`browser`/`ts`）没有目录，
+ * 因此永远不出现在「可以叠哪些层」的选项里。
+ */
+export function existsLayerDirectory(
+  templateRoot: string,
+  optionId: string,
+): boolean {
+  return existsSync(join(templateRoot, OVERLAY_DIR, optionId));
+}
+
+/**
+ * 列出可以在形态问答里勾选的层：框架与壳里有目录的那些。
+ *
+ * 故事源不是可叠加的层：TS 源、手写 `.story`、手写 `.json` 是同一棵
+ * `Resources/Stories/` 树上的三种文件形态，本来就能共存于一个工程，勾选它没有
+ * 「叠一层」的含义，所以 `sources` 维度不参与问答，只在脚本参数面（`--sources`）保留。
+ *
+ * 顺序沿用元数据里的维度顺序「框架 → 壳」，与合并顺序（骨架 → 框架 → 故事源 →
+ * 壳）不同——选项面按使用者心里的粒度排，合并顺序按覆盖关系排；维度内保持声明顺序。
+ */
+export function selectableLayers(
+  templateRoot: string,
+  meta: TemplateMeta,
+): TemplateOption[] {
+  return [...meta.frameworks, ...meta.shells].filter((option) =>
+    existsLayerDirectory(templateRoot, option.id),
+  );
+}
+
+/** 一对互斥的层 id，按选项面出现顺序排列 */
+export type LayerConflict = readonly [string, string];
+
+/**
+ * 从选中的层里找出互斥对。
+ *
+ * 只看「选中集合里同时出现了互斥的两方」，不关心是哪一方先声明的：单边声明即生效，
+ * 因此两边都声明也不会被算成两对。返回的每一对都按选项面顺序排列，便于报错文本稳定。
+ */
+export function findConflicts(
+  selected: readonly string[],
+  options: readonly TemplateOption[],
+): LayerConflict[] {
+  const order = new Map(options.map((option, index) => [option.id, index]));
+  const chosen = new Set(selected);
+  const pairs: LayerConflict[] = [];
+  const seen = new Set<string>();
+  for (const option of options) {
+    if (!chosen.has(option.id)) continue;
+    for (const excluded of option.excludes ?? []) {
+      if (!chosen.has(excluded)) continue;
+      const key = [option.id, excluded].sort().join("\u0000");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const pair = [option.id, excluded].sort(
+        (left, right) => (order.get(left) ?? 0) - (order.get(right) ?? 0),
+      ) as [string, string];
+      pairs.push(pair);
+    }
+  }
+  return pairs;
+}

package/src/shared/guards.ts

@@ -66,6 +66,20 @@ export function suggestProjectName(input: string): string {
   return collapsed.length > 0 ? collapsed : "lingfan-story";
 }
 
+/** 描述的字符上限：`package.json#description` 在 npm 生态里的通行上限 */
+export const DESCRIPTION_MAX_LENGTH = 200;
+
+/**
+ * 把自由文本收敛成可写入清单的描述。
+ *
+ * 全空白视为空，返回空串——调用方据此决定「不写这个字段」，而不是写一个空串进去。
+ * 超长直接截断而不报错：描述不影响任何路径与命令，没有理由为一个输入框拦住生成。
+ * 不校验字符集：它是给人看的自由文本，不是标识符。
+ */
+export function normalizeDescription(input: string): string {
+  return input.trim().slice(0, DESCRIPTION_MAX_LENGTH).trim();
+}
+
 /**
  * 把用户输入的版本号归一成 `^x.y.z`。
  *

package/src/shared/index.ts

@@ -2,7 +2,9 @@
 export { defaultCreateTexts, type CreateTexts } from "./texts.ts";
 export {
   caretRange,
+  DESCRIPTION_MAX_LENGTH,
   isValidProjectName,
+  normalizeDescription,
   suggestProjectName,
 } from "./guards.ts";
 export {

package/src/shared/texts.ts

@@ -11,30 +11,43 @@ export const defaultCreateTexts = {
   banner: "灵泛叙事引擎 · 工程生成器",
   help: [
     "用法：",
-    "  npm create @lingfan-engine [工程名] [选项]",
-    "  pnpm create @lingfan-engine [工程名] [选项]",
-    "  yarn create @lingfan-engine [工程名] [选项]",
+    "  npm create @lingfan-engine [工程名]",
+    "  pnpm create @lingfan-engine [工程名]",
+    "  bun create @lingfan-engine [工程名]",
+    "",
+    "工程名之后按提示回答：工程名 → 描述 → 形态（可多选）。",
+    "yarn 需要 2 及以上版本（classic 没有 create 子命令）；仍用 classic 时等价写法：",
+    "  yarn dlx create-@lingfan-engine [工程名]",
     "",
     "包管理器不限：生成后的安装命令与后续步骤按调用方自己的包管理器给出。",
     "选项：",
-    "  --template <id>       一次性指定形态，写作 框架[-壳[-故事源]]，如 vue-tauri",
-    "  -f, --framework <id>  框架（缺省取模板声明的默认值）",
-    "  -s, --shell <id>      壳（缺省取模板声明的默认值）",
-    "  -t, --sources <id>    故事源形态（缺省 ts，一般不必指定）",
+    "  --description <文本>  工程描述（写进 package.json 与 Resources/project.json；可留空）",
     "  -d, --dir <路径>      生成到哪个目录下（缺省 = 当前目录）",
     "      --install         生成后立即安装依赖",
     "      --overwrite       目标目录非空时清空后继续",
     "  -y, --yes             全部取缺省值，不进入交互问答",
     "  -h, --help            显示本说明",
     "",
+    "脚本用法：CI 里可以用参数直接指定形态，跳过问答。",
+    "  -f, --framework <id>  框架（none / vue / react）",
+    "  -s, --shell <id>      壳（browser / tauri / miniprogram）",
+    "  -t, --sources <id>    故事源形态（ts / story）",
+    "  --template <id>       等价写法：框架[-壳[-故事源]]，如 vue-tauri",
+    "",
     "示例：",
-    "  npm create @lingfan-engine my-story -- --template vue-browser",
-    "  npm create @lingfan-engine my-story -- --template vue-tauri --install",
+    "  npm create @lingfan-engine my-story",
+    "  npm create @lingfan-engine my-story --description 试菜单的小工程",
+    "  npm create @lingfan-engine my-story --yes --install",
   ].join("\n"),
   /** 交互问答的提示语 */
   promptProjectName: "工程名",
-  promptFramework: "框架",
-  promptShell: "壳",
+  promptDescription: "描述",
+  descriptionHint: "可留空；会写进 package.json 与 Resources/project.json",
+  promptLayers: "形态",
+  /** 非交互终端的处置 */
+  nonInteractive: "当前不是交互终端，还有未指定的项",
+  nonInteractiveHint:
+    "请补 --yes 取全部缺省，或用参数指定：--description --framework --shell --sources",
   promptExisting: "目标目录已存在且有内容，怎么处理",
   /** 参数校验失败 */
   nameRequired: "工程名不能为空",
@@ -44,6 +57,11 @@ export const defaultCreateTexts = {
   shellUnknown: "未知壳",
   sourcesUnknown: "未知故事源形态",
   templateMalformed: "形态写法不对，应为 框架[-壳[-故事源]]",
+  /** 形态多选 */
+  layersEmptyHint: "回车 = 只用骨架（框架无关 + 浏览器）",
+  layersInvalid: "没听懂这组编号，请用空格或逗号分隔的序号",
+  layersConflict: "选中的层互相排斥",
+  layersConflictHint: "重新选择（回车 = 全部缺省）",
   /** 目标目录已存在时的三种处置 */
   existingIgnore: "保留现有文件，同名覆盖",
   existingIgnoreHint: "只写本模板的文件，别的东西原地不动",