@waniwani/kit 0.1.8 → 0.1.10

package/README.md

@@ -20,9 +20,6 @@ oney/                          # what you write
 waniwani build                 # → .waniwani/, an ordinary npm project
 ```
 
-The machinery underneath is in [INTERNALS.md](https://github.com/WaniWani-AI/kit/blob/main/INTERNALS.md): template
-resolution, dependency overrides, CLI output, publishing, the full gap list.
-
 ## The three packages
 
 Three packages ship under the `@waniwani` scope. The pair people mix up is the
@@ -88,9 +85,28 @@ cd oney && npm run dev
 
 `init` writes a folder that already answers: an app config, one tool, and the
 widget that displays what the tool returned. It installs, and the dev
-server is one command away. `--minimal` scaffolds the config and the tool alone,
-`--name` sets the MCP server name, and running it inside an existing repo merges
-into that repo's `package.json` and `.gitignore` instead of replacing them.
+server is one command away. Running it inside an existing repo merges into that
+repo's `package.json` and `.gitignore` instead of replacing them.
+
+In a terminal it asks three questions, arrow keys and Enter:
+
+```
+┌  A new MCP app
+│
+◇  App name
+│  oney
+│
+◆  What should it come with?
+│  ● A tool and a widget (the hand-off between them, wired up)
+│  ○ Just a tool
+│  ↑/↓ to navigate • Enter: confirm
+└
+```
+
+Every question has a flag that answers it ahead of time (`--name`, `--minimal`,
+`--host`), and a question whose answer is already in hand is not asked. `--yes`
+takes every default and asks nothing, which is also what happens where there is
+no terminal to ask in: a pipe, or CI.
 
 Where the app lands follows the argument. `init oney` creates `oney/`, `init .`
 uses the current folder, and a bare `init` asks for a name and reads the answer
@@ -330,6 +346,22 @@ export default createFlow({ id: "split_payment", title, description, state })
 `showWidget({ tool: "select-plan" })` names a widget by its folder name, and the
 build check verifies that the folder exists.
 
+### Which SDK version an app gets
+
+`@waniwani/sdk` is a peer rather than a pin. The app's own `package.json` names
+the version, and this package states only the floor underneath it, so an app
+that upgrades keeps that choice through every build. Nothing here rewrites the
+range.
+
+`waniwani init` writes the newest published SDK it can reach, capped with a
+caret, and falls back to the declared floor when npm is unreachable. Set
+`WANIWANI_OFFLINE=1` to skip the lookup entirely.
+
+The SDK is 0.x, where a caret stops at the next minor. `^0.20.0` picks up
+0.20.1 on the next install and never crosses to 0.21 on its own. When a newer
+minor is published, `waniwani check` says so and names the one-line edit; taking
+it is the app's call, since under 0.x a minor is a breaking change.
+
 ### The api/ folder is for the browser
 
 A widget runs in an iframe on another origin, and it can call its own server
@@ -533,11 +565,13 @@ flowchart LR
 config file the repo carries:
 
 ```
-Where will this deploy?
-  1 Vercel                  — git push, or `vercel deploy --prebuilt`
-  2 Alpic                   — alpic.json comes from the build
-  3 Docker or self-hosted   — Dockerfile comes from the build
-  4 Not yet                 — nothing written, add it later
+◆  Where will this deploy?
+│  ● Vercel (git push, or `vercel deploy --prebuilt`)
+│  ○ Docker
+│  ○ Alpic
+│  ○ I don't know yet
+│  ↑/↓ to navigate • Enter: confirm
+└
 ```
 
 Only Vercel leaves anything behind, and it is four lines:
@@ -712,9 +746,10 @@ plumbing unless you pass `--force`, and it runs one way, with nothing to turn an
 ejected repo back.
 
 Your source has to move under `src/` for the compiled server to land where
-Skybridge's entry wrapper looks for it. The `rootDir` constraint behind that is
-written up in
-[the internals](https://github.com/WaniWani-AI/kit/blob/main/INTERNALS.md#why-eject-moves-the-source).
+Skybridge's entry wrapper looks for it. `tsc` derives `rootDir` from the widest
+common ancestor of the files it compiles, so source sitting beside `src/` rather
+than inside it pushes every emitted path down a level and the wrapper's import
+misses.
 
 ### The trade eject makes
 
@@ -737,9 +772,6 @@ What an ejected repo gives up is the generator, and with it:
   uploads as it is, and a git push builds it on the platform, but no command
   wraps either.
 - **`init` asks where an app deploys, and nothing else does.** A transfer, or an
-  app that answered `Not yet`, writes its own `vercel.json`.
+  app that answered `I don't know yet`, writes its own `vercel.json`.
 - **`useWidget` does not track yet.** Emitting `widget_render` and click events
   through `useWaniwani` automatically is the next step.
-
-Template pinning, the CI contract, publishing requirements and the rest of the
-gap list are in [INTERNALS.md](https://github.com/WaniWani-AI/kit/blob/main/INTERNALS.md).

package/dist/cli/init.js

@@ -14,6 +14,11 @@
  *                                 ./<name>/, the offered default (the current
  *                                 folder's name) scaffolds in place
  *
+ * In a terminal it asks three questions — the name, whether the widget comes
+ * with the tool, and where the app deploys — and every flag below answers one of
+ * them ahead of time, so a question is asked only where nothing has answered it.
+ * Piped, on CI, or under `--yes`, nothing is asked and the defaults stand.
+ *
  *   --name <name>    the MCP server name, default the directory name
  *   --host <host>    where it deploys: vercel, alpic, container, none
  *   --minimal        config and one tool, no widget
@@ -21,6 +26,10 @@
  *   --no-install     skip the dependency install
  *   --force          overwrite app files that are already there
  *
+ * What it copies lives in `templates/starter/`, as files rather than as strings
+ * in this module, so the repo's own type-checker and formatter run over the
+ * scaffold.
+ *
  * Running it inside a repo that already has files is expected and supported.
  * A `package.json` is merged rather than replaced, a `.gitignore` gains the
  * lines it lacks, and a `README.md` or `.env.example` that exists is left
@@ -30,15 +39,44 @@
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative } from "node:path";
-import { createInterface } from "node:readline/promises";
-import { bold, dim, green, red, yellow } from "./log.js";
-import { PACKAGE_VERSION } from "./manifest.js";
-import { installable } from "./peers.js";
-/** A directory name as an MCP server name: `My App` becomes `my-app`. */
+import { bold, dim, green, yellow } from "./log.js";
+import { PACKAGE_ROOT, PACKAGE_VERSION } from "./manifest.js";
+import { installable, preferred } from "./peers.js";
+import { askOne, askText, canAsk, close, fail, open } from "./prompt.js";
+import { latestVersion } from "./registry.js";
+/**
+ * The letters NFD leaves whole, because their Latin shape is not a base letter
+ * with a mark on it. Without these, `Straße` reaches the ASCII filter as `stra`
+ * and comes out `stra` — a name for a different product.
+ */
+const SPELLED_OUT = {
+    ß: "ss",
+    æ: "ae",
+    œ: "oe",
+    ø: "o",
+    đ: "d",
+    ð: "d",
+    ł: "l",
+    þ: "th",
+};
+/**
+ * A directory name as an MCP server name: `My App` becomes `my-app`.
+ *
+ * NFD splits an accented letter into a base letter and a combining mark, so
+ * dropping the marks turns `Café` into `cafe` rather than into `caf`, which is
+ * what dropping the composed character would give. What survives is a name npm
+ * and a filesystem both accept, and the answer as typed is kept as the title.
+ */
 function slugify(input) {
-    const slug = input
-        .trim()
-        .toLowerCase()
+    // Spelled out character by character rather than through a class of the same
+    // letters, so the table above is the only place they are written down. A class
+    // is where `đ` quietly becomes a `d` that maps to nothing.
+    const spelled = [...input.trim().toLowerCase()]
+        .map((letter) => SPELLED_OUT[letter] ?? letter)
+        .join("");
+    const slug = spelled
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
     return slug || "my-app";
@@ -63,21 +101,25 @@ function cleanTitle(input) {
  * What a new app depends on.
  *
  * Every version is read off this package's own manifest: `@waniwani/kit` at the
- * version of the CLI doing the scaffolding, and the four peers at the floors
- * this package declares, capped by `installable` so a floor does not install
- * the next major on the day it lands. A scaffold that wrote its own numbers
- * here would be the one file in the folder that can be wrong the day it is
- * created.
+ * version of the CLI doing the scaffolding, and the peers at the floors this
+ * package declares, capped by `installable` so a floor does not install the
+ * next major on the day it lands. A scaffold that wrote its own numbers here
+ * would be the one file in the folder that can be wrong the day it is created.
  *
- * `@waniwani/sdk` is written out even though a required peer is auto-installed
- * without it, because the app imports it directly — `flows/*.ts` calls
- * `createFlow` — and a package you import belongs in your own manifest rather
- * than arriving because something else asked for it.
+ * `@waniwani/sdk` is the exception, and `sdk` is where it comes from. The floor
+ * this package declares is frozen at release, so reading the SDK version off it
+ * scaffolds whatever was current when the kit shipped rather than what npm
+ * serves — see `preferred` in `./peers.ts`, which is what the caller resolves
+ * this through.
+ *
+ * It is written out at all, rather than left to arrive as a required peer,
+ * because the app imports it directly — `flows/*.ts` calls `createFlow` — and a
+ * package you import belongs in your own manifest.
  */
-function dependencies() {
+function dependencies(sdk) {
     return {
         "@waniwani/kit": `^${PACKAGE_VERSION}`,
-        "@waniwani/sdk": installable("@waniwani/sdk"),
+        "@waniwani/sdk": sdk,
         react: installable("react"),
         "react-dom": installable("react-dom"),
         zod: installable("zod"),
@@ -85,12 +127,52 @@ function dependencies() {
 }
 // ------------------------------------------------------------ scaffold content
 /**
- * The tool name and the widget name the scaffold uses. They appear in five
- * files, including inside prose the model reads, so they are named once.
+ * The tool name and the widget name the scaffold uses. They are the filenames
+ * under `templates/starter/`, and the filename is the name in this framework,
+ * so renaming one here means renaming the file. `starter()` throws if the two
+ * ever disagree.
  */
 const TOOL = "search-products";
 const WIDGET = "product-list";
-function packageJson(app) {
+/** Named once: it is looked up in the registry and written into the manifest. */
+const SDK = "@waniwani/sdk";
+/**
+ * The starter app, on disk.
+ *
+ * Real files, the way create-next-app ships `templates/app/ts/` and create-vite
+ * ships `template-react-ts/`: copied byte for byte, type-checked by
+ * `tsconfig.templates.json` against the kit this workspace builds, and formatted
+ * by the same biome config as the rest of the repo.
+ *
+ * The alternative is TypeScript inside a template literal in this module, which
+ * costs it every check the repo runs: `tsc` cannot see the JSX, biome cannot
+ * format it, and a change to `defineTool` or `useWidget` breaks the scaffold
+ * with nothing going red until somebody runs `waniwani init` by hand. Escaping
+ * is the visible half of that — a `\s` in the tool's regex has to be written
+ * `\\s`, and every backtick and `${` in the widget carries a backslash that is
+ * in no file anyone reads.
+ *
+ * Nothing here is interpolated, which is what makes that possible. The three
+ * files that do carry the app's own name — `package.json`, `waniwani.config.ts`
+ * and the README — are still written by this module, because they are data
+ * rather than sample code. create-next-app draws the same line, and its
+ * template folders carry no `package.json` at all.
+ *
+ * Two names differ on disk from what lands in the app. npm strips a `.gitignore`
+ * out of a published tarball, so the file is `gitignore` here and both CLIs
+ * above do the same (`gitignore` for Next, `_gitignore` for Vite); `.env.example`
+ * follows it for consistency rather than necessity.
+ */
+const STARTER = join(PACKAGE_ROOT, "templates", "starter");
+function starter(file) {
+    const source = join(STARTER, file);
+    if (!existsSync(source)) {
+        throw new Error(`the starter template is missing ${file} — looked in ${STARTER}. ` +
+            "An installed copy carries it through the `templates` entry in this package's `files`.");
+    }
+    return readFileSync(source, "utf-8");
+}
+function packageJson(app, sdk) {
     return `${JSON.stringify({
         name: app.name,
         private: true,
@@ -101,7 +183,7 @@ function packageJson(app) {
             build: "waniwani build",
             start: "waniwani start",
         },
-        dependencies: dependencies(),
+        dependencies: dependencies(sdk),
     }, null, 2)}\n`;
 }
 function appConfig(app) {
@@ -114,166 +196,6 @@ export default defineApp({
 });
 `;
 }
-function tool() {
-    return `import { defineTool } from "@waniwani/kit";
-import { z } from "zod";
-
-/**
- * The filename is the tool name, so this file is \`${TOOL}\`. Rename the
- * file and the tool renames with it.
- *
- * Swap CATALOGUE for whatever answers the question for real: a fetch, a
- * database, an internal API. \`run\` may be async.
- */
-const CATALOGUE = [
-	{ id: "aeron", name: "Aeron chair", price: 1290, blurb: "Mesh task chair, twelve-year warranty." },
-	{ id: "sayl", name: "Sayl chair", price: 545, blurb: "Suspension back, the light one." },
-	{ id: "nevi", name: "Nevi sit-stand desk", price: 890, blurb: "Electric, 70 to 120 cm." },
-	{ id: "ollin", name: "Ollin monitor arm", price: 235, blurb: "Single arm, holds up to 9 kg." },
-];
-
-export default defineTool({
-	// Shown to humans in connector UIs.
-	title: "Search the catalogue",
-	// The only thing the model reads before deciding to call this, so it says
-	// when to call it and what not to do instead.
-	description:
-		"Find products matching what the shopper asked for. Call this before naming any product or quoting any price, and never answer either from memory. Pass the shopper's own words as the query.",
-	// Zod shapes, written as plain objects instead of z.object({ ... }).
-	input: {
-		query: z.string().describe("What the shopper asked for, in their words, e.g. 'a chair under 600'."),
-	},
-	output: {
-		products: z.array(
-			z.object({
-				id: z.string(),
-				name: z.string(),
-				price: z.number().describe("Price in euros."),
-				blurb: z.string(),
-			}),
-		),
-	},
-	// Becomes MCP annotations. This tool reads and does nothing else.
-	hints: { readOnly: true },
-	run: ({ query }) => {
-		const terms = query.toLowerCase().split(/\\s+/).filter(Boolean);
-		const matched = CATALOGUE.filter((product) =>
-			terms.some((term) => \`\${product.name} \${product.blurb}\`.toLowerCase().includes(term)),
-		);
-		// The whole catalogue when nothing matched, so an early conversation has
-		// something on screen while you are still wiring this up.
-		return { products: matched.length > 0 ? matched : CATALOGUE };
-	},
-});
-`;
-}
-function widgetContract() {
-    return `import { defineWidget } from "@waniwani/kit";
-import { z } from "zod";
-
-const product = z.object({
-	id: z.string(),
-	name: z.string(),
-	price: z.number().describe("Price in euros."),
-	blurb: z.string().describe("One line about the product."),
-});
-
-/**
- * The folder name is the tool name, so this widget is \`${WIDGET}\`.
- *
- * \`data\` is one schema doing three jobs: the tool's input, its structured
- * output, and the props \`useWidget()\` hands ui.tsx. Server and UI cannot drift.
- *
- * This file is imported by the server and by the browser bundle, so it stays
- * free of React and CSS. The component sits next to it in ui.tsx.
- */
-export default defineWidget({
-	title: "Product list",
-	description:
-		"Show the product cards. Call this once ${TOOL} has returned products, passing them through unmodified. Frame it in one short sentence before calling, e.g. \\"Here's what fits.\\" The widget renders every name and price itself, so do NOT list them in text.",
-	data: {
-		query: z.string().describe("What the shopper asked for. Shown as the heading."),
-		products: z.array(product).describe("Products returned by ${TOOL}, unmodified."),
-	},
-	hints: { readOnly: true },
-	// Text handed to the model alongside the rendered widget. Use it to say what
-	// the model should not repeat, and what it should wait for.
-	llmText: (data) =>
-		\`The product list is on screen with \${data.products.length} products. It renders every name and price itself, so do NOT repeat them in text.
-
-Wait for the shopper to pick one, then answer about that product.\`,
-});
-`;
-}
-function widgetUi() {
-    return `import { useLayout, useSendFollowUpMessage, useWidget } from "@waniwani/kit/web";
-import widget from "./widget.js";
-
-const euros = (value: number) =>
-	new Intl.NumberFormat("en-IE", { style: "currency", currency: "EUR" }).format(value);
-
-export default function ProductList() {
-	// Typed off the widget's own \`data\` schema. No generated helpers, no server
-	// type import.
-	const { data } = useWidget(widget);
-	const sendFollowUp = useSendFollowUpMessage();
-
-	// The host hands the colour scheme to the view instead of to the browser, so
-	// \`prefers-color-scheme\` is the wrong signal and Tailwind's \`dark:\` variant is
-	// wired to a \`dark\` class (see the template's src/index.css). Every widget puts
-	// that class on its own root: a view is its own bundle in its own iframe, so
-	// there is no shared ancestor to hang it off.
-	const { theme } = useLayout();
-	const root = theme === "dark" ? "dark" : "";
-
-	// \`data\` arrives as soon as the host has the tool input, which on most hosts is
-	// before the server has responded. Render optimistically.
-	if (!data) {
-		return <div className={\`\${root} font-sans text-sm text-slate-500\`}>Loading…</div>;
-	}
-
-	return (
-		<div className={\`\${root} font-sans text-slate-900 dark:text-slate-100\`}>
-			<h1 className="mb-3 text-lg font-semibold tracking-tight">{data.query}</h1>
-
-			<div className="grid grid-cols-[repeat(auto-fit,minmax(180px,1fr))] gap-2.5">
-				{data.products.map((product) => (
-					<button
-						type="button"
-						key={product.id}
-						// A click becomes a message from the shopper, which is what moves
-						// the conversation on.
-						onClick={() => sendFollowUp(\`Tell me more about the \${product.name}.\`)}
-						className="flex cursor-pointer flex-col items-start gap-1 rounded-2xl border-[1.5px] border-slate-200 bg-white p-3.5 text-left transition duration-150 hover:-translate-y-px hover:border-slate-400 hover:shadow-lg hover:shadow-slate-900/10 dark:border-slate-700 dark:bg-slate-900 dark:hover:border-slate-500"
-						// What the model reads in place of the pixels.
-						data-llm={\`\${product.name}, \${euros(product.price)}: \${product.blurb}\`}
-					>
-						<span className="text-[22px] font-bold tracking-tight">{euros(product.price)}</span>
-						<span className="font-semibold">{product.name}</span>
-						<span className="text-[13px] text-slate-500 dark:text-slate-400">{product.blurb}</span>
-					</button>
-				))}
-			</div>
-		</div>
-	);
-}
-`;
-}
-function envExample() {
-    return `# Optional. Without it the app still runs: flows use MemoryKvStore and
-# withWaniwani degrades to a no-op. With it, flow state is hosted and tracking
-# reaches app.waniwani.ai.
-WANIWANI_API_KEY=
-WANIWANI_PUBLIC_KEY=
-`;
-}
-function gitignore() {
-    return `node_modules/
-.waniwani/
-.env
-.env.local
-`;
-}
 function readme(app) {
     return `# ${app.title}
 
@@ -326,21 +248,21 @@ const HOSTS = [
         note: "git push, or `vercel deploy --prebuilt`",
         deploy: ["git push", "vercel deploy --prebuilt    # or upload a local build"],
     },
+    {
+        id: "container",
+        label: "Docker",
+        note: "Dockerfile comes from the build",
+        deploy: ["waniwani build", "docker build .waniwani"],
+    },
     {
         id: "alpic",
         label: "Alpic",
         note: "alpic.json comes from the build",
         deploy: ["waniwani build", "cd .waniwani && alpic deploy"],
     },
-    {
-        id: "container",
-        label: "Docker or self-hosted",
-        note: "Dockerfile comes from the build",
-        deploy: ["waniwani build", "docker build .waniwani"],
-    },
     {
         id: "none",
-        label: "Not yet",
+        label: "I don't know yet",
         note: "nothing written, add it later",
         deploy: [],
     },
@@ -358,22 +280,27 @@ function vercelJson() {
         framework: null,
     }, null, 2)}\n`;
 }
-function scaffold(app, { minimal, host }) {
+function scaffold(app, { minimal, host, sdk }) {
     const files = [
         {
             path: "package.json",
-            contents: packageJson(app),
+            contents: packageJson(app, sdk),
             whenPresent: "merge",
             merge: mergePackageJson,
         },
-        { path: ".gitignore", contents: gitignore(), whenPresent: "merge", merge: mergeGitignore },
-        { path: ".env.example", contents: envExample(), whenPresent: "keep" },
+        {
+            path: ".gitignore",
+            contents: starter("gitignore"),
+            whenPresent: "merge",
+            merge: mergeGitignore,
+        },
+        { path: ".env.example", contents: starter("env.example"), whenPresent: "keep" },
         { path: "README.md", contents: readme(app), whenPresent: "keep" },
         { path: "waniwani.config.ts", contents: appConfig(app) },
-        { path: `tools/${TOOL}.ts`, contents: tool() },
+        { path: `tools/${TOOL}.ts`, contents: starter(`tools/${TOOL}.ts`) },
     ];
     if (!minimal) {
-        files.push({ path: `widgets/${WIDGET}/widget.ts`, contents: widgetContract() }, { path: `widgets/${WIDGET}/ui.tsx`, contents: widgetUi() });
+        files.push({ path: `widgets/${WIDGET}/widget.ts`, contents: starter(`widgets/${WIDGET}/widget.ts`) }, { path: `widgets/${WIDGET}/ui.tsx`, contents: starter(`widgets/${WIDGET}/ui.tsx`) });
     }
     // A repo that already answers Vercel its own way keeps that answer: the file
     // may carry a region, a cron, or a `maxDuration` this has no business
@@ -445,49 +372,17 @@ function write(file, contents) {
     mkdirSync(dirname(file), { recursive: true });
     writeFileSync(file, contents);
 }
-/** One question, with the default in parentheses and Enter taking it. */
-async function ask(question, fallback) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const answer = await rl.question(`${question} ${dim(`(${fallback})`)} `);
-        return answer.trim() || fallback;
-    }
-    finally {
-        rl.close();
-    }
-}
 /**
- * One question with a numbered list, and Enter taking the first option.
+ * The two shapes `init` scaffolds.
  *
- * Numbered rather than arrow-driven: this CLI writes plain lines everywhere else,
- * and a raw-mode menu is the one piece of terminal state a `waniwani init` piped
- * into something would leave behind.
+ * The pair is the default because the tool-to-widget hand-off is what nobody
+ * guesses from the type signatures, so the folder that demonstrates it is worth
+ * more than an empty one. `--minimal` is the same answer given ahead of time.
  */
-async function choose(question, options) {
-    const first = options[0];
-    console.log(`\n${bold(question)}`);
-    for (const [index, option] of options.entries()) {
-        console.log(`  ${dim(`${index + 1}`)} ${option.label} ${dim(`— ${option.note}`)}`);
-    }
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const answer = (await rl.question(`\nPick one ${dim(`(1, ${first.label})`)} `)).trim();
-        if (!answer)
-            return first.id;
-        // A number picks by position; anything else is matched against the labels,
-        // so typing `vercel` works as well as typing `1`.
-        const picked = Number(answer);
-        if (Number.isInteger(picked) && picked >= 1 && picked <= options.length) {
-            return options[picked - 1].id;
-        }
-        const lowered = answer.toLowerCase();
-        const named = options.find((option) => option.id === lowered || option.label.toLowerCase().startsWith(lowered));
-        return named?.id ?? first.id;
-    }
-    finally {
-        rl.close();
-    }
-}
+const CONTENTS = [
+    { value: "pair", label: "A tool and a widget", hint: "the hand-off between them, wired up" },
+    { value: "tool", label: "Just a tool", hint: "a config and one tool, nothing on screen" },
+];
 /**
  * The package manager that invoked this command, which npm, pnpm, yarn and bun
  * all announce in `npm_config_user_agent`. Nothing to detect from lockfiles: a
@@ -528,12 +423,26 @@ function install(root, manager) {
  * @returns a process exit code
  */
 export async function init(appRoot, flags, { targeted = true } = {}) {
-    const interactive = process.stdin.isTTY && !flags.yes && !flags.name;
+    // One question per unanswered decision, and none at all where there is nobody
+    // to answer. A flag counts as answered, which is what keeps `--name x --host
+    // vercel` from stopping on a prompt it has nothing left to ask.
+    const asking = canAsk() && !flags.yes;
     const suggested = slugify(basename(appRoot));
-    // One question, and both fields come out of the answer: `Acme Shop` gives the
-    // server the name `acme-shop` and keeps `Acme Shop` as the title. An answer
-    // that is already a slug gets a title with a capital on the front.
-    const answer = flags.name ?? (interactive ? await ask("App name", suggested) : suggested);
+    // Started here and awaited below, so the registry round trip happens behind
+    // the questions rather than in front of the first file write. It resolves to
+    // null on a slow or absent network and `preferred` falls back to the declared
+    // floor, so nothing about this scaffold depends on npm being reachable.
+    const publishedSdk = latestVersion(SDK);
+    if (asking) {
+        open(bold("A new MCP app"));
+    }
+    // Both fields come out of the one answer: `Acme Shop` gives the server the
+    // name `acme-shop` and keeps `Acme Shop` as the title. An answer that is
+    // already a slug gets a title with a capital on the front.
+    const named = asking && flags.name === undefined;
+    const answer = named
+        ? await askText("App name", suggested, (value) => value && !/[a-z0-9]/i.test(value) ? "a letter or a number, somewhere" : undefined)
+        : (flags.name ?? suggested);
     const name = slugify(answer);
     const typed = cleanTitle(answer);
     const app = { name, title: typed && typed !== name ? typed : titleize(name) };
@@ -542,21 +451,32 @@ export async function init(appRoot, flags, { targeted = true } = {}) {
     // create-next-app's one question reads. Taking the offered default leaves
     // everything where it is, since that default is the current folder's own name,
     // and `waniwani init .` names the current folder outright.
-    const root = !targeted && interactive && name !== suggested ? join(appRoot, name) : appRoot;
+    const root = !targeted && named && name !== suggested ? join(appRoot, name) : appRoot;
+    // The widget is what `--minimal` drops, so the flag and the question are the
+    // same decision reached two ways.
+    const minimal = flags.minimal !== undefined
+        ? Boolean(flags.minimal)
+        : asking
+            ? (await askOne("What should it come with?", CONTENTS)) === "tool"
+            : false;
     // Asked rather than assumed, because the answer decides whether the repo
     // carries a deploy file at all, and because seeing the four options is how
     // someone learns the app is not tied to one host.
     const host = typeof flags.host === "string"
         ? hostById(flags.host).id
-        : interactive
-            ? await choose("Where will this deploy?", HOSTS)
+        : asking
+            ? await askOne("Where will this deploy?", HOSTS.map((option) => ({
+                value: option.id,
+                label: option.label,
+                hint: option.note,
+            })))
             : hostById(undefined).id;
-    const files = scaffold(app, { minimal: Boolean(flags.minimal), host });
+    const files = scaffold(app, { minimal, host, sdk: preferred(SDK, await publishedSdk) });
     // Nothing is written until every collision is known, so a refusal leaves the
     // directory exactly as it was.
     const clashes = files.filter((file) => !file.whenPresent && existsSync(join(root, file.path)));
     if (clashes.length > 0 && !flags.force) {
-        console.error(`\n${red("✗")} ${bold("already an app folder here")}\n`);
+        fail(bold("already an app folder here"));
         for (const file of clashes) {
             console.error(`  ${file.path}`);
         }
@@ -589,7 +509,7 @@ export async function init(appRoot, flags, { targeted = true } = {}) {
         write(target, file.contents);
         actions.push([yellow("~"), file.path, "overwritten"]);
     }
-    console.log(`\n${green("✓")} ${bold(app.name)} ${dim(`→ ${root}`)}\n`);
+    close(`${bold(app.name)} ${dim(`→ ${root}`)}`);
     for (const [marker, path, note] of actions) {
         console.log(`  ${marker} ${path}${note ? ` ${dim(note)}` : ""}`);
     }
@@ -622,7 +542,7 @@ export async function init(appRoot, flags, { targeted = true } = {}) {
     console.log(`  ${ours ? `${manager} run dev` : `${RUNNERS[manager]} waniwani dev`}`);
     console.log(`\n${bold("Then")}`);
     console.log(`  ${dim("·")} edit ${bold(`tools/${TOOL}.ts`)} to answer with your own data`);
-    if (!flags.minimal) {
+    if (!minimal) {
         console.log(`  ${dim("·")} edit ${bold(`widgets/${WIDGET}/ui.tsx`)} for how it looks on screen`);
     }
     console.log(`  ${dim("·")} add ${bold("flows/<name>.ts")} for a multi-step conversation`);