@dunx/create-app 3.0.3 → 3.0.5

package/dist/cli.js

@@ -3,49 +3,726 @@
 import {
   FEATURES,
   ScaffoldError,
-  TEMPLATES,
-  featureNames,
+  blockingEntries,
   impliedBy,
+  isValidPackageName,
+  packageVersion,
+  resolveFeatures,
   scaffold
-} from "./chunk-x7s3axkt.js";
+} from "./chunk-5tn3ybzv.js";
 
 // src/cli.ts
 import { parseArgs } from "util";
 import { relative } from "path";
 
-// src/stdin.ts
-var readLine = async () => {
-  for await (const line of console) {
-    return typeof line === "string" ? line.trim() : "";
+// src/banner.ts
+var LOGO = [
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2554\u255D",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2554\u255D ",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551 \u2588\u2588\u2554\u2588\u2588\u2557 ",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u255D \u2588\u2588\u2557",
+  "\u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D"
+];
+var RAMP = [
+  "#00e6b8",
+  "#00d4aa",
+  "#12bfa4",
+  "#1fa89c",
+  "#2b8f92",
+  "#357788"
+];
+var INDENT = "  ";
+var NEEDS = 2 + 35 + 2;
+
+class Banner {
+  #style;
+  constructor(style) {
+    this.#style = style;
+  }
+  lines(width, version) {
+    const label = `create-app ${version}`;
+    if (width < NEEDS) {
+      return [
+        `${INDENT}${this.#style.bold(this.#style.accent("dunx"))} ${this.#style.muted(label)}`
+      ];
+    }
+    return [
+      ...LOGO.map((row, at) => `${INDENT}${this.#style.hex(RAMP[at] ?? "#00d4aa", row)}`),
+      `${INDENT}${this.#style.muted(label)}`
+    ];
+  }
+}
+Object.defineProperty(Banner, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "style: Style", typeOnly: "Style" }] });
+
+// src/keys.ts
+var KeyName = Object.freeze({
+  Up: "up",
+  Down: "down",
+  Left: "left",
+  Right: "right",
+  Home: "home",
+  End: "end",
+  Enter: "enter",
+  Space: "space",
+  Tab: "tab",
+  ShiftTab: "shiftTab",
+  Backspace: "backspace",
+  ClearLine: "clearLine",
+  Escape: "escape",
+  Interrupt: "interrupt",
+  Char: "char",
+  Unknown: "unknown"
+});
+var key = (name, char = "") => ({ name, char });
+var CONTROLS = Object.freeze({
+  3: KeyName.Interrupt,
+  4: KeyName.Interrupt,
+  8: KeyName.Backspace,
+  9: KeyName.Tab,
+  10: KeyName.Enter,
+  13: KeyName.Enter,
+  21: KeyName.ClearLine,
+  32: KeyName.Space,
+  127: KeyName.Backspace
+});
+var FINALS = Object.freeze({
+  A: KeyName.Up,
+  B: KeyName.Down,
+  C: KeyName.Right,
+  D: KeyName.Left,
+  F: KeyName.End,
+  H: KeyName.Home,
+  Z: KeyName.ShiftTab
+});
+var TILDES = Object.freeze({
+  "1": KeyName.Home,
+  "4": KeyName.End,
+  "7": KeyName.Home,
+  "8": KeyName.End
+});
+var ESCAPE = 27;
+var isParameter = (code) => code >= 32 && code <= 63;
+
+class KeyDecoder {
+  #pending = "";
+  #decoder = new TextDecoder("utf-8");
+  push(bytes) {
+    this.#pending += this.#decoder.decode(bytes, { stream: true });
+    const keys = [];
+    while (this.#pending.length > 0) {
+      const next = this.#take();
+      if (next === undefined)
+        break;
+      keys.push(next);
+    }
+    return keys;
+  }
+  #take() {
+    const buffer = this.#pending;
+    const code = buffer.charCodeAt(0);
+    if (code === ESCAPE)
+      return this.#takeEscape(buffer);
+    const named = CONTROLS[code];
+    if (named !== undefined) {
+      this.#pending = buffer.slice(1);
+      return key(named);
+    }
+    if (code < 32) {
+      this.#pending = buffer.slice(1);
+      return key(KeyName.Unknown);
+    }
+    const size = code >= 55296 && code <= 56319 ? 2 : 1;
+    this.#pending = buffer.slice(size);
+    return key(KeyName.Char, buffer.slice(0, size));
+  }
+  #takeEscape(buffer) {
+    if (buffer.length === 1) {
+      this.#pending = "";
+      return key(KeyName.Escape);
+    }
+    const introducer = buffer[1];
+    if (introducer !== "[" && introducer !== "O") {
+      this.#pending = buffer.slice(2);
+      return key(KeyName.Unknown);
+    }
+    let at = 2;
+    while (at < buffer.length && isParameter(buffer.charCodeAt(at)))
+      at += 1;
+    if (at === buffer.length)
+      return;
+    const parameters = buffer.slice(2, at);
+    const final = buffer[at] ?? "";
+    this.#pending = buffer.slice(at + 1);
+    if (final === "~")
+      return key(TILDES[parameters] ?? KeyName.Unknown);
+    return key(FINALS[final] ?? KeyName.Unknown);
+  }
+}
+
+// src/prompt.ts
+class CancelledError extends Error {
+  name = "CancelledError";
+}
+
+class Prompt {
+  #done = false;
+  #cancelled = false;
+  #answer;
+  press(key2) {
+    if (this.#done)
+      return;
+    if (key2.name === KeyName.Interrupt || key2.name === KeyName.Escape) {
+      this.#cancelled = true;
+      this.#done = true;
+      return;
+    }
+    this.handle(key2);
+  }
+  finish(answer) {
+    this.#answer = answer;
+    this.#done = true;
+  }
+  get done() {
+    return this.#done;
+  }
+  get cancelled() {
+    return this.#cancelled;
+  }
+  get answer() {
+    if (!this.#done || this.#cancelled) {
+      throw new Error("The prompt was not answered.");
+    }
+    return this.#answer;
+  }
+}
+var CSI = "\x1B[";
+var HIDE_CURSOR = `${CSI}?25l`;
+var SHOW_CURSOR = `${CSI}?25h`;
+var ERASE_DOWN = `${CSI}0J`;
+var up = (lines) => lines > 0 ? `${CSI}${lines}A` : "";
+
+class PromptRunner {
+  #tty;
+  constructor(tty) {
+    this.#tty = tty;
+  }
+  async ask(prompt) {
+    const width = Math.max(20, this.#tty.columns - 1);
+    let painted = 0;
+    const paint = () => {
+      const height = Math.max(3, this.#tty.rows - 1);
+      const lines = prompt.frame(width, height).slice(0, height);
+      this.#tty.write(`${up(painted)}${ERASE_DOWN}${lines.join(`
+`)}
+`);
+      painted = lines.length;
+    };
+    this.#tty.write(HIDE_CURSOR);
+    try {
+      await new Promise((resolve) => {
+        paint();
+        this.#tty.open((key2) => {
+          prompt.press(key2);
+          if (prompt.done)
+            resolve();
+          else
+            paint();
+        });
+      });
+    } finally {
+      this.#tty.close();
+      const closing = prompt.cancelled ? "" : `${prompt.summary(width)}
+`;
+      this.#tty.write(`${up(painted)}${ERASE_DOWN}${closing}${SHOW_CURSOR}`);
+    }
+    if (prompt.cancelled)
+      throw new CancelledError("Cancelled.");
+    return prompt.answer;
+  }
+}
+Object.defineProperty(PromptRunner, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "tty: Tty", typeOnly: "Tty" }] });
+
+// src/style.ts
+var CSI2 = "\x1B[";
+var RESET = `${CSI2}0m`;
+var tone = (hex) => Bun.color(hex, "ansi-256") ?? "";
+var ACCENT = tone("#00d4aa");
+var MUTED = tone("#8a8f98");
+var DANGER = tone("#e5534b");
+var WARN = tone("#d29922");
+
+class Style {
+  #enabled;
+  constructor(enabled = Bun.enableANSIColors) {
+    this.#enabled = enabled;
+  }
+  #wrap(code, text) {
+    return this.#enabled && code !== "" ? `${code}${text}${RESET}` : text;
+  }
+  accent(text) {
+    return this.#wrap(ACCENT, text);
+  }
+  muted(text) {
+    return this.#wrap(MUTED, text);
+  }
+  danger(text) {
+    return this.#wrap(DANGER, text);
+  }
+  warn(text) {
+    return this.#wrap(WARN, text);
+  }
+  bold(text) {
+    return this.#wrap(`${CSI2}1m`, text);
+  }
+  invert(text) {
+    return this.#wrap(`${CSI2}7m`, text);
+  }
+  hex(colour, text) {
+    return this.#wrap(tone(colour), text);
+  }
+  clip(text, width) {
+    if (width <= 0)
+      return "";
+    if (Bun.stringWidth(text) <= width)
+      return text;
+    return `${Bun.sliceAnsi(text, 0, Math.max(0, width - 1))}${this.muted("\u2026")}`;
+  }
+}
+Object.defineProperty(Style, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "enabled: boolean = Bun.enableANSIColors", optional: true }] });
+
+// src/tty.ts
+class Tty {
+}
+
+class ProcessTty extends Tty {
+  #decoder = new KeyDecoder;
+  #input;
+  #output;
+  #listener;
+  constructor(input = process.stdin, output = process.stdout) {
+    super();
+    this.#input = input;
+    this.#output = output;
+  }
+  static available() {
+    return process.stdin.isTTY === true && typeof process.stdin.setRawMode === "function" && process.stdout.isTTY === true;
+  }
+  get columns() {
+    return this.#output.columns ?? 80;
+  }
+  get rows() {
+    return this.#output.rows ?? 24;
+  }
+  write(text) {
+    this.#output.write(text);
+  }
+  open(onKey) {
+    const listener = (chunk) => {
+      for (const key2 of this.#decoder.push(chunk))
+        onKey(key2);
+    };
+    this.#listener = listener;
+    this.#input.setRawMode?.(true);
+    this.#input.resume();
+    this.#input.on("data", listener);
+  }
+  close() {
+    if (this.#listener === undefined)
+      return;
+    this.#input.off("data", this.#listener);
+    this.#listener = undefined;
+    this.#input.setRawMode?.(false);
+    this.#input.pause();
+  }
+}
+Object.defineProperty(ProcessTty, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "input: KeySource = process.stdin", optional: true }, { unresolved: "output: FrameSink = process.stdout", optional: true }] });
+
+// src/wizard.ts
+import { basename, resolve } from "path";
+
+// src/prompts.ts
+var ASKING = "?";
+var ANSWERED = "\u2713";
+var POINTER = "\u276F";
+var CHOSEN = "\u25C9";
+var REQUIRED = "\u25C8";
+var UNCHOSEN = "\u25CB";
+
+class TextPrompt extends Prompt {
+  style;
+  title;
+  #value;
+  #at;
+  #error = "";
+  constructor(style, title, initial) {
+    super();
+    this.style = style;
+    this.title = title;
+    this.#value = initial;
+    this.#at = initial.length;
+  }
+  validate(_value) {
+    return;
+  }
+  hint() {
+    return "Enter to accept. Ctrl+C to cancel.";
+  }
+  frame(width) {
+    const text = this.#value;
+    const at = this.#at;
+    const under = at < text.length ? text.slice(at, at + 1) : " ";
+    const drawn = text.slice(0, at) + this.style.invert(under) + text.slice(at + 1);
+    const footer = this.#error === "" ? this.style.muted(this.hint()) : this.style.danger(this.#error);
+    return [
+      `${this.style.accent(ASKING)} ${this.style.bold(this.title)}`,
+      this.style.clip(`  ${drawn}`, width),
+      this.style.clip(`  ${footer}`, width)
+    ];
+  }
+  summary(width) {
+    return this.style.clip(`${this.style.accent(ANSWERED)} ${this.title}  ${this.style.accent(this.#value)}`, width);
+  }
+  handle(key2) {
+    this.#error = "";
+    switch (key2.name) {
+      case KeyName.Char:
+        this.#value = this.#value.slice(0, this.#at) + key2.char + this.#value.slice(this.#at);
+        this.#at += key2.char.length;
+        return;
+      case KeyName.Space:
+        this.#error = "A space is not usable here.";
+        return;
+      case KeyName.Backspace:
+        if (this.#at === 0)
+          return;
+        this.#value = this.#value.slice(0, this.#at - 1) + this.#value.slice(this.#at);
+        this.#at -= 1;
+        return;
+      case KeyName.ClearLine:
+        this.#value = "";
+        this.#at = 0;
+        return;
+      case KeyName.Left:
+        this.#at = Math.max(0, this.#at - 1);
+        return;
+      case KeyName.Right:
+        this.#at = Math.min(this.#value.length, this.#at + 1);
+        return;
+      case KeyName.Home:
+        this.#at = 0;
+        return;
+      case KeyName.End:
+        this.#at = this.#value.length;
+        return;
+      case KeyName.Enter: {
+        const problem = this.validate(this.#value);
+        if (problem === undefined)
+          this.finish(this.#value);
+        else
+          this.#error = problem;
+        return;
+      }
+      default:
+        return;
+    }
+  }
+}
+Object.defineProperty(TextPrompt, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "protected readonly style: Style", typeOnly: "Style" }, { unresolved: "readonly title: string" }, { unresolved: "initial: string" }] });
+
+class ConfirmPrompt extends Prompt {
+  style;
+  title;
+  #value;
+  constructor(style, title, initial) {
+    super();
+    this.style = style;
+    this.title = title;
+    this.#value = initial;
+  }
+  #option(label, active) {
+    return active ? this.style.invert(` ${label} `) : this.style.muted(` ${label} `);
+  }
+  frame(width) {
+    return [
+      `${this.style.accent(ASKING)} ${this.style.bold(this.title)}`,
+      this.style.clip(`  ${this.#option("yes", this.#value)} ${this.#option("no", !this.#value)}`, width),
+      this.style.clip(`  ${this.style.muted("y or n. Enter takes the highlighted one.")}`, width)
+    ];
+  }
+  summary(width) {
+    const answer = this.#value ? "yes" : "no";
+    return this.style.clip(`${this.style.accent(ANSWERED)} ${this.title}  ${this.style.accent(answer)}`, width);
+  }
+  handle(key2) {
+    const typed = key2.char.toLowerCase();
+    if (typed === "y") {
+      this.finish(true);
+      return;
+    }
+    if (typed === "n") {
+      this.finish(false);
+      return;
+    }
+    if (key2.name === KeyName.Left || key2.name === KeyName.Right || key2.name === KeyName.Tab || key2.name === KeyName.Space) {
+      this.#value = !this.#value;
+      return;
+    }
+    if (key2.name === KeyName.Enter)
+      this.finish(this.#value);
+  }
+}
+Object.defineProperty(ConfirmPrompt, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "private readonly style: Style", typeOnly: "Style" }, { unresolved: "private readonly title: string" }, { unresolved: "initial: boolean" }] });
+var CHROME = 4;
+
+class SelectPrompt extends Prompt {
+  style;
+  title;
+  items;
+  #cursor = 0;
+  #offset = 0;
+  #chosen = new Set;
+  constructor(style, title, items, initial = []) {
+    super();
+    this.style = style;
+    this.title = title;
+    this.items = items;
+    for (const value of initial)
+      this.#chosen.add(value);
+  }
+  implied(_chosen) {
+    return new Set;
+  }
+  notes(_chosen) {
+    return [];
+  }
+  #marker(value, implied) {
+    if (this.#chosen.has(value))
+      return this.style.accent(CHOSEN);
+    if (implied.has(value))
+      return this.style.warn(REQUIRED);
+    return this.style.muted(UNCHOSEN);
+  }
+  #window(budget) {
+    const visible = Math.max(1, Math.min(this.items.length, budget));
+    if (this.#cursor < this.#offset)
+      this.#offset = this.#cursor;
+    if (this.#cursor >= this.#offset + visible) {
+      this.#offset = this.#cursor - visible + 1;
+    }
+    this.#offset = Math.min(this.#offset, Math.max(0, this.items.length - visible));
+    return this.items.slice(this.#offset, this.#offset + visible);
+  }
+  frame(width, height) {
+    const implied = this.implied(this.#chosen);
+    const notes = this.notes(this.#chosen);
+    const pad = Math.max(...this.items.map((item) => item.label.length));
+    const window = this.#window(height - CHROME - notes.length);
+    const lines = [
+      `${this.style.accent(ASKING)} ${this.style.bold(this.title)}  ` + this.style.muted(this.#count(implied))
+    ];
+    if (this.#offset > 0) {
+      lines.push(this.style.muted(`    \u2191 ${this.#offset} more`));
+    }
+    for (const [index, item] of window.entries()) {
+      const at = this.#offset + index;
+      const pointer = at === this.#cursor ? this.style.accent(POINTER) : " ";
+      const label = at === this.#cursor ? this.style.bold(item.label.padEnd(pad)) : item.label.padEnd(pad);
+      lines.push(this.style.clip(`${pointer} ${this.#marker(item.value, implied)} ${label}  ${this.style.muted(item.hint)}`, width));
+    }
+    const below = this.items.length - this.#offset - window.length;
+    if (below > 0)
+      lines.push(this.style.muted(`    \u2193 ${below} more`));
+    for (const note of notes) {
+      lines.push(this.style.clip(`  ${this.style.warn(note)}`, width));
+    }
+    lines.push(this.style.clip(`  ${this.style.muted("Space toggles. \u2191\u2193 moves. a all, n none. Enter continues.")}`, width));
+    return lines;
+  }
+  #count(implied) {
+    if (this.#chosen.size === 0)
+      return "nothing chosen yet";
+    const extra = implied.size === 0 ? "" : `, ${implied.size} pulled in`;
+    return `${this.#chosen.size} chosen${extra}`;
+  }
+  summary(width) {
+    const chosen = this.#ordered();
+    const answer = chosen.length === 0 ? "none, the minimal template" : chosen.join(", ");
+    return this.style.clip(`${this.style.accent(ANSWERED)} ${this.title}  ${this.style.accent(answer)}`, width);
+  }
+  #ordered() {
+    return this.items.map((item) => item.value).filter((value) => this.#chosen.has(value));
+  }
+  #move(by) {
+    const count = this.items.length;
+    this.#cursor = (this.#cursor + by + count) % count;
+  }
+  handle(key2) {
+    switch (key2.name) {
+      case KeyName.Up:
+      case KeyName.ShiftTab:
+        this.#move(-1);
+        return;
+      case KeyName.Down:
+      case KeyName.Tab:
+        this.#move(1);
+        return;
+      case KeyName.Home:
+        this.#cursor = 0;
+        return;
+      case KeyName.End:
+        this.#cursor = this.items.length - 1;
+        return;
+      case KeyName.Space: {
+        const value = this.items[this.#cursor]?.value;
+        if (value === undefined)
+          return;
+        if (!this.#chosen.delete(value))
+          this.#chosen.add(value);
+        return;
+      }
+      case KeyName.Enter:
+        this.finish(this.#ordered());
+        return;
+      case KeyName.Char:
+        this.#type(key2.char);
+        return;
+      default:
+        return;
+    }
+  }
+  #type(char) {
+    if (char === "k")
+      this.#move(-1);
+    else if (char === "j")
+      this.#move(1);
+    else if (char === "a")
+      for (const item of this.items)
+        this.#chosen.add(item.value);
+    else if (char === "n")
+      this.#chosen.clear();
+  }
+}
+Object.defineProperty(SelectPrompt, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "protected readonly style: Style", typeOnly: "Style" }, { unresolved: "readonly title: string" }, { unresolved: "protected readonly items: readonly SelectItem[]" }, { unresolved: "initial: readonly string[] = []", optional: true }] });
+
+// src/wizard.ts
+var DEFAULT_TARGET = "my-api";
+
+class DirectoryPrompt extends TextPrompt {
+  validate(value) {
+    return value.trim() === "" ? "Name a directory to write into." : undefined;
+  }
+  hint() {
+    return 'Enter to accept. A single "." writes into the directory you are in.';
+  }
+}
+
+class PackageNamePrompt extends TextPrompt {
+  validate(value) {
+    return isValidPackageName(value) ? undefined : "npm forbids uppercase, and a leading dot or underscore.";
+  }
+}
+
+class FeaturePrompt extends SelectPrompt {
+  constructor(style, initial) {
+    super(style, "Features", FEATURES.map((feature) => ({
+      value: feature.name,
+      label: feature.name,
+      hint: feature.summary
+    })), initial);
+  }
+  #resolved(chosen) {
+    return resolveFeatures([...chosen]);
+  }
+  implied(chosen) {
+    return new Set(impliedBy([...chosen], this.#resolved(chosen)));
+  }
+  notes(chosen) {
+    const resolved = this.#resolved(chosen);
+    const lines = [];
+    const implied = impliedBy([...chosen], resolved);
+    if (implied.length > 0) {
+      const verb = implied.length === 1 ? "comes" : "come";
+      lines.push(`${implied.join(", ")} ${verb} along as a requirement.`);
+    }
+    const services = new Map;
+    for (const feature of resolved) {
+      if (feature.service === undefined)
+        continue;
+      const named = services.get(feature.service) ?? [];
+      named.push(feature.name);
+      services.set(feature.service, named);
+    }
+    for (const [service, named] of services) {
+      const verb = named.length === 1 ? "needs" : "need";
+      lines.push(`${named.join(", ")} ${verb} ${service}.`);
+    }
+    return lines;
+  }
+}
+Object.defineProperty(FeaturePrompt, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "style: Style", typeOnly: "Style" }, { unresolved: "initial: readonly string[]" }] });
+
+class Wizard {
+  #runner;
+  #style;
+  constructor(runner, style) {
+    this.#runner = runner;
+    this.#style = style;
   }
-  return "";
+  async run(defaults) {
+    const target = defaults.target ?? await this.#runner.ask(new DirectoryPrompt(this.#style, "Directory", DEFAULT_TARGET));
+    const name = await this.#name(defaults, target);
+    const features = await this.#runner.ask(new FeaturePrompt(this.#style, defaults.features));
+    const force = await this.#force(defaults, target);
+    return { target, name, features, force };
+  }
+  async#name(defaults, target) {
+    if (defaults.name !== undefined)
+      return defaults.name;
+    const derived = basename(resolve(defaults.cwd, target));
+    if (isValidPackageName(derived))
+      return derived;
+    return this.#runner.ask(new PackageNamePrompt(this.#style, "Package name", slug(derived)));
+  }
+  async#force(defaults, target) {
+    if (defaults.force)
+      return true;
+    const blocking = blockingEntries(resolve(defaults.cwd, target));
+    if (blocking.length === 0)
+      return false;
+    const shown = blocking.slice(0, 3).join(", ");
+    const rest = blocking.length > 3 ? `, +${blocking.length - 3} more` : "";
+    const proceed = await this.#runner.ask(new ConfirmPrompt(this.#style, `${target} already has files in it (${shown}${rest}). Write into it anyway?`, false));
+    if (!proceed)
+      throw new CancelledError("Nothing written.");
+    return true;
+  }
+}
+Object.defineProperty(Wizard, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "runner: PromptRunner", typeOnly: "PromptRunner" }, { unresolved: "style: Style", typeOnly: "Style" }] });
+var slug = (value) => {
+  const lowered = value.toLowerCase().replace(/[^a-z0-9\-._~]+/g, "-").replace(/^[-._]+/, "").replace(/-+$/, "");
+  return lowered === "" ? DEFAULT_TARGET : lowered;
 };
 
 // src/cli.ts
 var USAGE = `Scaffold a new dunx application.
 
-  bunx @dunx/create-app <directory> [options]
+  bunx @dunx/create-app [directory]
+
+It asks. Up and down move, space toggles a feature, Enter takes the selection,
+and the list says which features your choices pull in and which need a service
+running. Nothing about the app is chosen by a flag.
 
 Options:
-  --name <name>       package name for the app (default: the directory name)
-  --with <a,b,c>      features to compose the app from (see --list)
-  --all               every feature
-  --template <name>   ${TEMPLATES.join(" | ")} (default: minimal, when no --with)
-  --list              print the features and exit
-  --force             write into a directory that already has files in it
-  --yes, -y           take the default selection without prompting
-  --help              print this
-
-With no --with and no prompt, you get the minimal template: five files, one route.
-With features, the wiring is generated around them and each feature's directory is
-copied from dunx's own examples/full, which CI runs and tours on every push.
+  --name <name>   package name for the app (default: the directory name)
+  --force         write into a directory that already has files in it
+  --yes, -y       skip the questions and take the minimal template
+  --help          print this
+
+With no terminal to ask in - piped, or CI - it takes the minimal template rather
+than blocking on a question nothing can answer. To choose features from a script,
+call \`scaffold({ features })\` from \`@dunx/create-app\` instead.
 `;
-var featureList = () => FEATURES.map((feature) => {
-  const needs = feature.requires.length === 0 ? "" : ` (pulls in ${feature.requires.join(", ")})`;
-  const service = feature.service === undefined ? "" : `  [needs ${feature.service}]`;
-  return `  ${feature.name.padEnd(12)}${feature.summary}${needs}${service}`;
-}).join(`
-`);
 function fail(message) {
   console.error(message);
   process.exit(1);
@@ -55,10 +732,6 @@ var { values, positionals } = parseArgs({
   allowPositionals: true,
   options: {
     name: { type: "string" },
-    template: { type: "string" },
-    with: { type: "string" },
-    all: { type: "boolean", default: false },
-    list: { type: "boolean", default: false },
     force: { type: "boolean", default: false },
     yes: { type: "boolean", default: false, short: "y" },
     help: { type: "boolean", default: false, short: "h" }
@@ -68,59 +741,55 @@ if (values.help === true) {
   console.log(USAGE);
   process.exit(0);
 }
-if (values.list === true) {
-  console.log(`Features:
-${featureList()}`);
-  process.exit(0);
-}
+var style = new Style;
 var target = positionals[0];
-if (target === undefined) {
-  fail(`Missing the target directory.
+var withoutAsking = () => {
+  if (target === undefined) {
+    fail(`Missing the target directory.
 
 ${USAGE}`);
-}
-var split = (value) => value.split(",").map((part) => part.trim()).filter((part) => part !== "");
-var ask = async () => {
-  if (values.all === true)
-    return featureNames;
-  if (values.with !== undefined)
-    return split(values.with);
-  if (values.yes === true || !process.stdin.isTTY)
-    return [];
-  console.log(`Features (empty for the minimal template):
-${featureList()}
-`);
-  console.log("Names or numbers, comma separated. `all` for everything.");
-  process.stdout.write("> ");
-  const answer = await readLine();
-  if (answer === "")
-    return [];
-  if (answer === "all")
-    return featureNames;
-  return split(answer).map((part) => {
-    const index = Number(part);
-    return Number.isInteger(index) && index >= 1 && index <= FEATURES.length ? FEATURES[index - 1]?.name ?? part : part;
-  });
-};
-try {
-  const requested = await ask();
-  const result = await scaffold({
+  }
+  return {
     target,
     ...values.name === undefined ? {} : { name: values.name },
-    ...values.template === undefined ? {} : { template: values.template },
-    features: requested,
+    features: [],
     force: values.force === true
+  };
+};
+var byAsking = async () => {
+  const tty = new ProcessTty;
+  const banner = new Banner(style).lines(tty.columns, await packageVersion());
+  console.log(["", ...banner, ""].join(`
+`));
+  const wizard = new Wizard(new PromptRunner(tty), style);
+  const answers = await wizard.run({
+    target,
+    name: values.name,
+    features: [],
+    force: values.force === true,
+    cwd: process.cwd()
   });
+  return answers;
+};
+var interactive = values.yes !== true && ProcessTty.available();
+try {
+  const options = interactive ? await byAsking() : withoutAsking();
+  const result = await scaffold(options);
   const where = relative(process.cwd(), result.directory);
-  console.log(where === "" ? `Created ${result.name} here` : `Created ${result.name} in ${where}/`);
+  console.log(where === "" ? `
+Created ${result.name} here` : `
+Created ${result.name} in ${where}/`);
   if (result.features.length === 0) {
     console.log(`  ${result.files.length} files from the ${result.template} template
 `);
   } else {
-    const implied = impliedBy(requested, FEATURES.filter((feature) => result.features.includes(feature.name)));
-    console.log(`  ${result.files.length} files, ${result.features.length} features: ` + `${result.features.join(", ")}`);
+    const requested = options.features ?? [];
+    const implied = result.features.filter((name) => !requested.includes(name));
+    const noun = result.features.length === 1 ? "feature" : "features";
+    console.log(`  ${result.files.length} files, ${result.features.length} ${noun}: ` + `${result.features.join(", ")}`);
     if (implied.length > 0) {
-      console.log(`  ${implied.join(", ")} came along as requirements`);
+      const as = implied.length === 1 ? "a requirement" : "requirements";
+      console.log(`  ${implied.join(", ")} came along as ${as}`);
     }
     const services = FEATURES.filter((feature) => result.features.includes(feature.name) && feature.service !== undefined);
     for (const feature of services) {
@@ -132,8 +801,12 @@ try {
   if (where !== "")
     console.log(`  cd ${where}`);
   console.log("  bun install");
-  console.log("  bun run start");
+  console.log(`  bun run dev  ${style.muted("# or `start`, which does not watch")}`);
 } catch (error) {
+  if (error instanceof CancelledError) {
+    console.log(style.muted(error.message));
+    process.exit(130);
+  }
   if (error instanceof ScaffoldError)
     fail(error.message);
   throw error;